/*
 * Copyright (c) 2022 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import {
  numDefine98,
  numDefine99,
  numDefine100,
  numDefine101,
  numDefine102,
  numDefine103,
  numDefine128,
  numDefine140,
  numDefine111,
  numDefine146,
  numDefine147,
  numDefine108,
  numDefine110,
  numDefine104,
  numDefine105,
  numDefine106,
  numDefine28,
  numDefine2,
  numDefine13,
  numDefine19,
  numDefine18,
  numDefine3,
  numDefine16,
  numDefine5,
  numDefine6,
  numDefine7,
  numDefine8,
  numDefine135,
  numDefine138,
  numDefine142,
  numDefine143,
  numDefine144,
  numDefine149,
  numDefine150,
  numDefine151,
  numDefine154,
  numDefine156,
  numDefine158,
  numDefine159,
  numDefine160,
  numDefine162,
  numDefine164,
  numDefine166,
  numDefine172,
  numDefine173,
  numDefine171,
  numDefine179,
  numDefine29,
  numDefine20,
  numDefine14,
  numDefine72,
  numDefine73,
  numDefine74,
  numDefine75,
  numDefine76,
  numDefine77,
  numDefine78,
  numDefine79,
  numDefine80,
  numDefine82,
  numDefine83,
  numDefine86,
  numDefine87,
  numDefine88,
  numDefine90,
  numDefine91,
  numDefine92,
  numDefine93,
  numDefine96,
  numDefine97,
  numDefine30,
  numDefine21,
  numDefine31,
  numDefine22,
  numDefine32,
  numDefine23,
  numDefine33,
  numDefine10,
  numDefine9,
  numDefine4,
  numDefine15,
  numDefine11,
  numDefine48,
  numDefineNeg2,
  numDefine46,
  numDefineNeg8,
  numDefine56,
  numDefine64,
  numDefine58,
  numDefine65535,
  numDefineNeg16,
  numDefine27,
  numDefine17,
  numDefine12,
  numDefine255,
  numDefineNeg24,
  numDefine54,
  numDefineNeg4,
  numDefine24,
  numDefineNeg40,
  numDefineNeg6,
  numDefineNeg12,
  numDefineNeg3,
  numDefine23760,
  numDefine40,
  numDefine47,
  numDefine36,
  numDefine40048,
  numDefine69,
  numDefine61,
  numDefine50,
  numDefine516,
  numDefine24576,
  numDefine25344,
  numDefine26928,
  numDefine27720,
  numDefine26880,
  numDefine26136,
  numDefine23436,
  numDefine22620,
  numDefine24192,
  numDefine25740,
  numDefine26520,
  numDefine25704,
  numDefine24960,
  numDefine25,
  numDefine67,
  numDefine26,
  numDefine63,
  numDefine129,
  numDefine38,
  numDefine42,
  numDefine71,
  numDefine39,
  numDefine45,
  numDefine34,
  numDefine43,
  numDefine44,
  numDefine184,
  numDefine182,
  numDefine49,
  numDefine68,
  numDefine65,
  numDefine41,
  numDefine124,
  numDefine66,
  numDefine57,
  numDefine52,
  numDefine51,
  numDefine35,
  numDefine37,
  numDefine113,
  numDefine70,
  numDefine120,
  numDefine608,
  numDefine180,
  numDefine256,
  numDefine1664,
  numDefine259,
  numDefine1028,
  numDefine62336,
  numDefine53,
  numDefine1024,
  numDefine9344,
  numDefine60,
  numDefine324,
  numDefine300,
  numDefine1000,
  numDefine55765,
  numDefine93459,
  numDefine45135,
  numDefine11935,
  numDefine41823,
  numDefine67296,
  numDefineNeg3048,
  numDefine41813,
  numDefineNeg7,
  numDefineNeg5,
  numDefine3036,
  numDefine760,
  numDefine761,
  numDefine762,
  numDefine3040,
  numDefineNeg16408,
  numDefineNeg4097,
  numDefineNeg16384,
  numDefine263,
  numDefineNeg83648,
  numDefine83647,
  numDefineNeg48,
  numDefine77215,
  numDefineNeg184,
  numDefineNeg136,
  numDefine197,
  numDefine198,
  numDefineNeg145,
  numDefine114,
  numDefine119,
  numDefine122,
  numDefine112,
  numDefineNeg102,
  numDefineNeg144,
  numDefineNeg36,
  numDefine10240,
  numDefine62,
  numDefine115,
  numDefine117,
  numDefineNeg135,
  numDefine167,
  numDefine176,
  numDefineNeg134,
  numDefine121,
  numDefineNeg122,
  numDefine123,
  numDefine0xfffffffc,
  numDefineNeg62144,
  numDefineNeg43009,
  numDefine35071,
  numDefine59360,
  numDefine35072,
  numDefineNeg48576,
  numDefineNeg24288,
  numDefine2047,
  numDefineNeg1023,
  numDefineFloat312,
  numDefineFloat05,
  numDefineFloat101,
  numDefineN10,
  numDefineNeg10,
  numDefineFloat902,
  numDefine70910,
  numDefine65534,
  numDefine11680,
  numDefine65280,
  numDefineNeg112,
  numDefineNeg32,
  numDefineNeg21,
  numDefineNeg80,
  numDefineNeg20,
  numDefineNeg64,
  numDefineNeg23,
  numDefineNeg22,
  numDefine2049,
  numDefine2048,
  numDefine131,
  numDefine97151,
  numDefineFloat4044,
  numDefineNeg120,
  numDefineFloat9165,
  numDefineNeg49440,
  numDefineN6,
  numDefineNeg160,
  numDefineNeg1032,
  numDefineNeg1024,
  numDefineNeg65,
  numDefine280,
  numDefine127,
  numDefine277,
  numDefine175,
  numDefine278,
  numDefine356,
  numDefine420,
  numDefine275,
  numDefine48576,
  numDefine359,
  numDefine53216,
  numDefine3060,
  numDefine16384,
  numDefine361,
  numDefine360,
  numDefine357,
  numDefine355,
  numDefine353,
  numDefine847,
  numDefine199,
  numDefine367,
  numDefine735,
  numDefine341,
  numDefine703,
  numDefine669,
  numDefine419,
  numDefine188,
  numDefineNeg88609,
  numDefineNeg30432,
  numDefine44872,
  numDefine95039,
  numDefine08864,
  numDefine91752
} from './mandreel-part1/Class/DevNumber';

import { MandreelCanvas, MandreelCanvasDiv } from './mandreel-part1/Class/MandreelElement';
import { MandreelDocument } from './mandreel-part1/Class/MandreelDocument';
import { mandreelWindow, GetItemArr } from './mandreel-part1/Class/MandreelWindow';
import { commonVariable, heapClassInst } from './mandreel-part1/Class/CommonClassFile';
import { tlsfFree } from './mandreelFile7';

let debug: boolean = false;

function deBugLog(msg: string | number): void {
  if (debug) {
    print(msg);
  }
}

class SwriteIndex {
  swriteIndexNew: number = 0;
  zn21btCollisionDispatcher19defaultNearCallbackER16btBroadphasePairRSRK16btDispatcherInfoIndex: number = 0;
  znk13btConvexShape44localGetSupportVertexWithoutMarginNonVirtualERK9btVector3Index: number = 0;
  znk13btConvexShape31localGetSupportVertexNonVirtualERK9btVector3Index: number = 0;
  cmpfacetsIndex: number = 0;
  cmplocalesIndex: number = 0;
  imandreelRestoreGlcontextIndex: number = 0;
  iMandreelTextureAsyncGetPackOffsetIndex: number = 0;
  iMandreelTextureAsyncIsCompressedIndex: number = 0;
  imandreelViewportResizeIndex: number = 0;
  mandreelFlashTcpOnErrorIndex: number = 0;
  z31MandreelDefaultDebugMsgCallbackiPKcIndex: number = 0;
  fwriteIndex: number = 0;
  mandreelInternalSetResolutionIndex: number = 0;
  resizeIndex: number = 0;
  zn16btCollisionWorld24ClosestRayResultCallback15addSingleResultERNS14LocalRayResultEbIndex: number = 0;
  zn13BenchmarkDemo15displayCallbackEvIndex: number = 0;
  znk16btCollisionWorld17RayResultCallback14needsCollisionEP17btBroadphaseProxyIndex: number = 0;
  zn16btCollisionWorld24ClosestRayResultCallbackD0EvIndex: number = 0;
  zn13BenchmarkDemo20clientMoveAndDisplayEvIndex: number = 0;
  zn7RagDollD0EvIndex: number = 0;
  zn7RagDollD1EvIndex: number = 0;
  zn16btCollisionWorld24ClosestRayResultCallbackD1EvIndex: number = 0;
  zn20btDefaultMotionState17setWorldTransformERK11btTransformIndex: number = 0;
  znk20btDefaultMotionState17getWorldTransformER11btTransformIndex: number = 0;
  zn15DemoApplication16getDynamicsWorldEvIndex: number = 0;
  zn20btDefaultMotionStateD0EvIndex: number = 0;
  zn20btDefaultMotionStateD1EvIndex: number = 0;
  zn15DemoApplication6myinitEvIndex: number = 0;
  zn13BenchmarkDemoD1EvIndex: number = 0;
  zn13BenchmarkDemoD0EvIndex: number = 0;
  zn15DemoApplication20localCreateRigidBodyEfRK11btTransformP16btCollisionShapeIndex: number = 0;
}

let swriteIndex = new SwriteIndex();

class TlsfPtr {
  tlsfPtr: number = 0;
}

let tlsfPtr = new TlsfPtr();

class CreateFileId {
  buffer: ArrayBuffer;
  offset: number;
  count: number = 0;
  byteArray: Uint8Array;

  constructor(buffer: ArrayBuffer, offset: number = 0, byteArray: Uint8Array = new Uint8Array()) {
    this.buffer = buffer;
    this.offset = offset;
    this.byteArray = byteArray;
  }
}

let mandreelTotalMemory = numDefine08864;
let mandreelStackMemory = numDefine48576;
let mandreelHeapMemory = numDefine91752;
let functionTable: Array<(num: number) => void> = [(): void => {}];

let mandreelPosFunctionTable = 1;
let gStackPointer: number = mallocInt(mandreelStackMemory);

class MandreelBulkClass {
  mandreelWidth: number = 0;
  mandreelHeight: number = 0;
}

class ArrayUniformLocations extends MandreelBulkClass {
  uniformLocationsCurrentId: number = 0;
  arrayUniformLocations: Array<number> = [0];
}

let arrayIdsOgl: Array<ArrayUniformLocations> = new Array();

class ImandreelGl {
  texture2D: number = 0;
  rgb: number = 0;
  rgba: number = 0;
  luminance: number = 0;
  alpha: number = 0;
  luminanceAlpha: number = 0;
  unsignedByte: number = 0;
  unsignedShort565: number = 0;
  unsignedShort4444: number = 0;
  unsignedShort5551: number = 0;
  staticDraw: number = 0;

  createTexture(): ArrayUniformLocations {
    return new ArrayUniformLocations();
  }

  createRenderbuffer(): ArrayUniformLocations {
    return new ArrayUniformLocations();
  }

  createFramebuffer(): ArrayUniformLocations {
    return new ArrayUniformLocations();
  }

  createBuffer(): ArrayUniformLocations {
    return new ArrayUniformLocations();
  }

  isEnabled(x: number): number {
    return 1;
  }

  getUniformLocation(x: ArrayUniformLocations, y: string): number {
    return 1;
  }

  getAttribLocation(x: object, y: string): number {
    return 1;
  }

  getProgramInfoLog(x: object): string {
    return '';
  }

  getShaderInfoLog(x: object): string {
    return '';
  }

  getProgramParameter(x: object, y: number): number {
    return 1;
  }

  getActiveAttrib(x: object, y: number): ResultClass {
    return new ResultClass();
  }

  getActiveUniform(x: object, y: number): ResultClass {
    return new ResultClass();
  }

  getShaderParameter(x: ArrayUniformLocations | null, y: number): number {
    return 0;
  }

  getError(): number {
    return 0;
  }
}

class ResultClass {
  size: number = 0;
  type: number = 0;
  name: string = '';
}

let imandreelGl: ImandreelGl | null = null;

let mandreelCacheFiles: Map<string, number> = new Map();

class Stufix {
  gMandreelDatafilesSufix: string = '.dat';
}

let sufix = new Stufix();

let fileIds = Array<CreateFileId | null>();
let currentFileId = numDefine20;
let argTestLocal = mallocInt(numDefine8);
let llvmDoubleAddr = mallocInt(numDefine8);
let llvmErrno = mallocInt(numDefine4);
let zgvzn11btMatrix3x311getIdentityEvE14identityMatrix = mallocInt(numDefine8);
let zgvzn11btTransform11getIdentityEvE17identityTransform = mallocInt(numDefine8);
let landscape02Vtx = mallocInt(numDefine23760);
let ztin16btCollisionWorld17RayResultCallbackE = mallocInt(numDefine8);
let ztsn16btCollisionWorld17RayResultCallbackE = mallocInt(numDefine40);
let ztvn16btCollisionWorld24ClosestRayResultCallbackE = mallocInt(numDefine24);
let ztin16btCollisionWorld24ClosestRayResultCallbackE = mallocInt(numDefine12);
let ztsn16btCollisionWorld24ClosestRayResultCallbackE = mallocInt(numDefine47);
let zti13btMotionState = mallocInt(numDefine8);
let zts13btMotionState = mallocInt(numDefine16);
let ztv20btDefaultMotionState = mallocInt(numDefine24);
let zti20btDefaultMotionState = mallocInt(numDefine12);
let zts20btDefaultMotionState = mallocInt(numDefine23);
let zti17btTypedConstraint = mallocInt(numDefine24);
let zts17btTypedConstraint = mallocInt(numDefine20);
let zti13btTypedObject = mallocInt(numDefine8);
let zts13btTypedObject = mallocInt(numDefine16);
let ztv7RagDoll = mallocInt(numDefine16);
let zti7RagDoll = mallocInt(numDefine8);
let zts7RagDoll = mallocInt(numDefine9);
let ztv13BenchmarkDemo = mallocInt(numDefine36);
let zti13BenchmarkDemo = mallocInt(numDefine12);
let zts13BenchmarkDemo = mallocInt(numDefine16);
let zti15DemoApplication = mallocInt(numDefine8);
let zts15DemoApplication = mallocInt(numDefine18);
let zl10raycastBar = mallocInt(numDefine40048);
let twoEStr3 = mallocInt(numDefine48);
let twoEStr4 = mallocInt(numDefine69);
let twoEStr5 = mallocInt(numDefine61);
let twoEStr6 = mallocInt(numDefine50);
let twoEStr7 = mallocInt(numDefine27);
let zl7TaruVtx = mallocInt(numDefine516);
let landscapeVtx = mallocInt(numDefine32);
let landscape01Vtx = mallocInt(numDefine24576);
let landscape03Vtx = mallocInt(numDefine24576);
let landscape04Vtx = mallocInt(numDefine25344);
let landscape05Vtx = mallocInt(numDefine26928);
let landscape06Vtx = mallocInt(numDefine27720);
let landscape07Vtx = mallocInt(numDefine26880);
let landscape08Vtx = mallocInt(numDefine26136);
let landscapeVtxCount = mallocInt(numDefine32);
let landscapeIdx = mallocInt(numDefine32);
let landscape01Idx = mallocInt(numDefine23436);
let landscape02Idx = mallocInt(numDefine22620);
let landscape03Idx = mallocInt(numDefine23436);
let landscape04Idx = mallocInt(numDefine24192);
let landscape05Idx = mallocInt(numDefine25740);
let landscape06Idx = mallocInt(numDefine26520);
let landscape07Idx = mallocInt(numDefine25704);
let landscape08Idx = mallocInt(numDefine24960);
let landscapeIdxCount = mallocInt(numDefine32);
let zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E02E02E0 = mallocInt(numDefine4);
let zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E12E02E1 = mallocInt(numDefine4);
let zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E22E02E2 = mallocInt(numDefine4);
let zzn11btTransform11getIdentityEvE17identityTransform = mallocInt(numDefine64);
let ztv14BenchmarkDemo4 = mallocInt(numDefine36);
let zti14BenchmarkDemo4 = mallocInt(numDefine12);
let zts14BenchmarkDemo4 = mallocInt(numDefine17);
let zl14benchmarkDemo4 = mallocInt(numDefine80);
let zti21btBroadphaseInterface = mallocInt(numDefine8);
let zts21btBroadphaseInterface = mallocInt(numDefine24);
let zti25btOverlappingPairCallback = mallocInt(numDefine8);
let zts25btOverlappingPairCallback = mallocInt(numDefine28);
let zti22btOverlappingPairCache = mallocInt(numDefine12);
let zts22btOverlappingPairCache = mallocInt(numDefine25);
let ztv15btNullPairCache = mallocInt(numDefine76);
let zti15btNullPairCache = mallocInt(numDefine12);
let zts15btNullPairCache = mallocInt(numDefine18);
let twoEStr11 = mallocInt(numDefine36);
let twoEStr112 = mallocInt(numDefine67);
let twoEStr213 = mallocInt(numDefine18);
let twoEStr314 = mallocInt(numDefine18);
let ztv20btAxisSweep3InternalItE = mallocInt(numDefine64);
let zti20btAxisSweep3InternalItE = mallocInt(numDefine12);
let zts20btAxisSweep3InternalItE = mallocInt(numDefine26);
let ztv12btAxisSweep3 = mallocInt(numDefine64);
let zti12btAxisSweep3 = mallocInt(numDefine12);
let zts12btAxisSweep3 = mallocInt(numDefine15);
let ztv20btCollisionAlgorithm = mallocInt(numDefine28);
let zti20btCollisionAlgorithm = mallocInt(numDefine8);
let zts20btCollisionAlgorithm = mallocInt(numDefine23);
let ztin6btDbvt8ICollideE = mallocInt(numDefine8);
let ztsn6btDbvt8ICollideE = mallocInt(numDefine19);
let twoEStr1118 = mallocInt(numDefine63);
let twoEStr22 = mallocInt(numDefine16);
let ztv18btDbvtTreeCollider = mallocInt(numDefine36);
let zti18btDbvtTreeCollider = mallocInt(numDefine12);
let zts18btDbvtTreeCollider = mallocInt(numDefine21);
let ztv19BroadphaseRayTester = mallocInt(numDefine36);
let zti19BroadphaseRayTester = mallocInt(numDefine12);
let zts19BroadphaseRayTester = mallocInt(numDefine22);
let ztv20BroadphaseAabbTester = mallocInt(numDefine36);
let zti20BroadphaseAabbTester = mallocInt(numDefine12);
let zts20BroadphaseAabbTester = mallocInt(numDefine23);
let twoEStr18 = mallocInt(numDefine73);
let ztv16btDbvtBroadphase = mallocInt(numDefine64);
let zti16btDbvtBroadphase = mallocInt(numDefine12);
let zts16btDbvtBroadphase = mallocInt(numDefine19);
let ztv12btDispatcher = mallocInt(numDefine64);
let zti12btDispatcher = mallocInt(numDefine8);
let zts12btDispatcher = mallocInt(numDefine15);
let zti21btNodeOverlapCallback = mallocInt(numDefine8);
let zts21btNodeOverlapCallback = mallocInt(numDefine24);
let twoEStr10 = mallocInt(numDefine2);
let twoEStr212 = mallocInt(numDefine18);
let twoEStr313 = mallocInt(numDefine69);
let twoEStr414 = mallocInt(numDefine36);
let twoEStr515 = mallocInt(numDefine36);
let twoEStr616 = mallocInt(numDefine36);
let twoEStr717 = mallocInt(numDefine36);
let twoEStr820 = mallocInt(numDefine36);
let twoEStr9 = mallocInt(numDefine36);
let gOverlappingPairs = mallocInt(numDefine4);
let zti17btOverlapCallback = mallocInt(numDefine8);
let zts17btOverlapCallback = mallocInt(numDefine20);
let ztvzn28btHashedOverlappingPairCache19cleanProxyFromPairsEP17btBroadphaseProxyP12btDispatcherE17CleanPairCallback = mallocInt(numDefine20);
let ztizn28btHashedOverlappingPairCache19cleanProxyFromPairsEP17btBroadphaseProxyP12btDispatcherE17CleanPairCallback = mallocInt(numDefine12);
let ztszn28btHashedOverlappingPairCache19cleanProxyFromPairsEP17btBroadphaseProxyP12btDispatcherE17CleanPairCallback = mallocInt(numDefine110);
let ztvzn28btHashedOverlappingPairCache37removeOverlappingPairsContainingProxyEP17btBroadphaseProxyP12btDispatcherE18RemovePairCallback =
  mallocInt(numDefine20);
let ztizn28btHashedOverlappingPairCache37removeOverlappingPairsContainingProxyEP17btBroadphaseProxyP12btDispatcherE18RemovePairCallback =
  mallocInt(numDefine12);
let ztszn28btHashedOverlappingPairCache37removeOverlappingPairsContainingProxyEP17btBroadphaseProxyP12btDispatcherE18RemovePairCallback =
  mallocInt(numDefine129);
let gRemovePairs = mallocInt(numDefine4);
let ztv28btHashedOverlappingPairCache = mallocInt(numDefine76);
let zti28btHashedOverlappingPairCache = mallocInt(numDefine12);
let zts28btHashedOverlappingPairCache = mallocInt(numDefine31);
let twoEStr121 = mallocInt(numDefine79);
let gAddedPairs = mallocInt(numDefine4);
let twoEStr222 = mallocInt(numDefine38);
let twoEStr323 = mallocInt(numDefine77);
let twoEStr424 = mallocInt(numDefine38);
let twoEStr525 = mallocInt(numDefine38);
let twoEStr626 = mallocInt(numDefine42);
let twoEStr727 = mallocInt(numDefine22);
let gFindPairs = mallocInt(numDefine4);
let twoEStr32 = mallocInt(numDefine23);
let twoEStr133 = mallocInt(numDefine23);
let twoEStr234 = mallocInt(numDefine21);
let twoEStr335 = mallocInt(numDefine24);
let ztv14btQuantizedBvh = mallocInt(numDefine36);
let zti14btQuantizedBvh = mallocInt(numDefine8);
let zts14btQuantizedBvh = mallocInt(numDefine17);
let twoEStr537 = mallocInt(numDefine71);
let twoEStr638 = mallocInt(numDefine48);
let twoEStr739 = mallocInt(numDefine13);
let twoEStr941 = mallocInt(numDefine14);
let twoEStr1143 = mallocInt(numDefine29);
let maxIterations = mallocInt(numDefine4);
let twoEStr1844 = mallocInt(numDefine19);
let twoEStr1921 = mallocInt(numDefine32);
let twoEStr21 = mallocInt(numDefine7);
let twoEStr2246 = mallocInt(numDefine13);
let ztv30btActivatingCollisionAlgorithm = mallocInt(numDefine28);
let zti30btActivatingCollisionAlgorithm = mallocInt(numDefine12);
let zts30btActivatingCollisionAlgorithm = mallocInt(numDefine33);
let twoEStr59 = mallocInt(numDefine14);
let twoEStr160 = mallocInt(numDefine69);
let ztv26btBoxBoxCollisionAlgorithm = mallocInt(numDefine28);
let zti26btBoxBoxCollisionAlgorithm = mallocInt(numDefine12);
let zts26btBoxBoxCollisionAlgorithm = mallocInt(numDefine29);
let zti36btDiscreteCollisionDetectorInterface = mallocInt(numDefine8);
let zts36btDiscreteCollisionDetectorInterface = mallocInt(numDefine39);
let ztv16btBoxBoxDetector = mallocInt(numDefine20);
let zti16btBoxBoxDetector = mallocInt(numDefine12);
let zts16btBoxBoxDetector = mallocInt(numDefine19);
let twoEStr65 = mallocInt(numDefine12);
let twoEStr166 = mallocInt(numDefine71);
let gNumManifold = mallocInt(numDefine4);
let ztin36btDiscreteCollisionDetectorInterface6ResultE = mallocInt(numDefine8);
let ztsn36btDiscreteCollisionDetectorInterface6ResultE = mallocInt(numDefine48);
let ztv23btCollisionPairCallback = mallocInt(numDefine20);
let zti23btCollisionPairCallback = mallocInt(numDefine12);
let zts23btCollisionPairCallback = mallocInt(numDefine26);
let twoEStr169 = mallocInt(numDefine45);
let twoEStr270 = mallocInt(numDefine26);
let twoEStr371 = mallocInt(numDefine14);
let twoEStr472 = mallocInt(numDefine34);
let twoEStr573 = mallocInt(numDefine76);
let ztv21btCollisionDispatcher = mallocInt(numDefine64);
let zti21btCollisionDispatcher = mallocInt(numDefine12);
let zts21btCollisionDispatcher = mallocInt(numDefine24);
let twoEStr674 = mallocInt(numDefine23);
let twoEStr775 = mallocInt(numDefine6);
let twoEStr876 = mallocInt(numDefine6);
let twoEStr977 = mallocInt(numDefine73);
let ztv17btCollisionObject = mallocInt(numDefine36);
let zti17btCollisionObject = mallocInt(numDefine8);
let zts17btCollisionObject = mallocInt(numDefine20);
let twoEStr78 = mallocInt(numDefine27);
let ztin16btCollisionWorld20ConvexResultCallbackE = mallocInt(numDefine8);
let ztsn16btCollisionWorld20ConvexResultCallbackE = mallocInt(numDefine43);
let zti30btConvexPenetrationDepthSolver = mallocInt(numDefine8);
let zts30btConvexPenetrationDepthSolver = mallocInt(numDefine33);
let ztvn12btConvexCast10CastResultE = mallocInt(numDefine24);
let ztin12btConvexCast10CastResultE = mallocInt(numDefine8);
let ztsn12btConvexCast10CastResultE = mallocInt(numDefine29);
let ztvzn16btCollisionWorld13rayTestSingleERK11btTransformS2P17btCollisionObjectPK16btCollisionShapeS2RNS17RayResultCallbackEE15LocalInfoAdder2 =
  mallocInt(numDefine24);
let ztizn16btCollisionWorld13rayTestSingleERK11btTransformS2P17btCollisionObjectPK16btCollisionShapeS2RNS17RayResultCallbackEE15LocalInfoAdder2 =
  mallocInt(numDefine12);
let ztszn16btCollisionWorld13rayTestSingleERK11btTransformS2P17btCollisionObjectPK16btCollisionShapeS2RNS17RayResultCallbackEE15LocalInfoAdder2 =
  mallocInt(numDefine140);
let ztvzn16CollsionQuerySingObjectPK = mallocInt(numDefine24);
let ztizn16btCollisionWorldCollisionShape = mallocInt(numDefine12);
let ztszn16btConvexResultLocalInfoAdder = mallocInt(numDefine164);
let zti24btBroadphaseAabbCallback = mallocInt(numDefine8);
let zts24btBroadphaseAabbCallback = mallocInt(numDefine27);
let zti23btBroadphaseRayCallback = mallocInt(numDefine12);
let zts23btBroadphaseRayCallback = mallocInt(numDefine26);
let ztv17DebugDrawcallback = mallocInt(numDefine44);
let zti17DebugDrawcallback = mallocInt(numDefine32);
let zts17DebugDrawcallback = mallocInt(numDefine20);
let zti18btTriangleCallback = mallocInt(numDefine8);
let zts18btTriangleCallback = mallocInt(numDefine21);
let zti31btInternalTriangleIndexCallback = mallocInt(numDefine8);
let zts31btInternalTriangleIndexCallback = mallocInt(numDefine34);
let ztv16btCollisionWorld = mallocInt(numDefine56);
let zti16btCollisionWorld = mallocInt(numDefine8);
let zts16btCollisionWorld = mallocInt(numDefine19);
let zti16btManifoldResult = mallocInt(numDefine12);
let zts16btManifoldResult = mallocInt(numDefine19);
let ztv21btSingleSweepCallback = mallocInt(numDefine20);
let zti21btSingleSweepCallback = mallocInt(numDefine12);
let zts21btSingleSweepCallback = mallocInt(numDefine24);
let ztv19btSingleRayCallback = mallocInt(numDefine20);
let zti19btSingleRayCallback = mallocInt(numDefine12);
let zts19btSingleRayCallback = mallocInt(numDefine22);
let twoEStr382 = mallocInt(numDefine23);
let twoEStr483 = mallocInt(numDefine76);
let twoEStr584 = mallocInt(numDefine19);
let twoEStr685 = mallocInt(numDefine42);
let twoEStr786 = mallocInt(numDefine16);
let twoEStr887 = mallocInt(numDefine71);
let twoEStr988 = mallocInt(numDefine82);
let ztvzn16CollsionQuerySingConvex = mallocInt(numDefine24);
let ztizn16btCollisionTransformConvexcastCallback0 = mallocInt(numDefine12);
let ztszn16btCollisionQuerySingleShapeRK11 = mallocInt(numDefine184);
let zti28btTriangleConvexcastCallback = mallocInt(numDefine12);
let zts28btTriangleConvexcastCallback = mallocInt(numDefine31);
let ztvzn16CollsionQuery = mallocInt(numDefine24);
let ztizn16btCollisionWorld17objectQuerySing = mallocInt(numDefine12);
let ztszn16btCollisionWorld17object = mallocInt(numDefine182);
let ztvzn16CollsionTestCallback0 = mallocInt(numDefine24);
let ztizn16btCollisionWorld13rayObjectPK16bt = mallocInt(numDefine12);
let ztszn16btCollisionObjectPK = mallocInt(numDefine156);
let zti25btTriangleRaycastCallback = mallocInt(numDefine12);
let zts25btTriangleRaycastCallback = mallocInt(numDefine28);
let ztvzn16CollsionTestERK = mallocInt(numDefine24);
let ztizn16btCollisionWorld13rayTestSingle = mallocInt(numDefine12);
let ztszn16btCollisionWorld = mallocInt(numDefine154);
let twoEStr1089 = mallocInt(numDefine16);
let twoEStr1190 = mallocInt(numDefine34);
let twoEStr1291 = mallocInt(numDefine26);
let twoEStr1392 = mallocInt(numDefine26);
let twoEStr1493 = mallocInt(numDefine20);
let zzn16btCollisionWorld16updateSingleAabbEP17btCollisionObjectE8reportMe2EB = mallocInt(1);
let twoEStr1594 = mallocInt(numDefine49);
let twoEStr1695 = mallocInt(numDefine68);
let twoEStr1796 = mallocInt(numDefine65);
let twoEStr1897 = mallocInt(numDefine9);
let twoEStr1998 = mallocInt(numDefine12);
let ztv22btCompoundLeafCallback = mallocInt(numDefine36);
let zti22btCompoundLeafCallback = mallocInt(numDefine12);
let zts22btCompoundLeafCallback = mallocInt(numDefine25);
let twoEStr99 = mallocInt(numDefine42);
let twoEStr1100 = mallocInt(numDefine83);
let twoEStr2101 = mallocInt(numDefine43);
let twoEStr3102 = mallocInt(numDefine41);
let twoEStr4103 = mallocInt(numDefine43);
let twoEStr5104 = mallocInt(numDefine43);
let twoEStr6105 = mallocInt(numDefine9);
let twoEStr7106 = mallocInt(numDefine41);
let ztv28btCompoundCollisionAlgorithm = mallocInt(numDefine28);
let zti28btCompoundCollisionAlgorithm = mallocInt(numDefine12);
let zts28btCompoundCollisionAlgorithm = mallocInt(numDefine31);
let twoEStr109 = mallocInt(numDefine9);
let ztv24btConvexTriangleCallback = mallocInt(numDefine20);
let zti24btConvexTriangleCallback = mallocInt(numDefine12);
let zts24btConvexTriangleCallback = mallocInt(numDefine27);
let zn33btCollisionObjectS1RK = mallocInt(numDefine20);
let ztizn33btConvexConcave = mallocInt(numDefine12);
let ztszn33btConvex = mallocInt(numDefine158);
let ztv15btTriangleShape = mallocInt(numDefine124);
let zti15btTriangleShape = mallocInt(numDefine12);
let zts15btTriangleShape = mallocInt(numDefine18);
let zti23btPolyhedralConvexShape = mallocInt(numDefine12);
let zts23btPolyhedralConvexShape = mallocInt(numDefine26);
let zti21btConvexInternalShape = mallocInt(numDefine12);
let zts21btConvexInternalShape = mallocInt(numDefine24);
let zti13btConvexShape = mallocInt(numDefine12);
let zts13btConvexShape = mallocInt(numDefine16);
let zti16btCollisionShape = mallocInt(numDefine8);
let zts16btCollisionShape = mallocInt(numDefine19);
let twoEStr1110 = mallocInt(numDefine26);
let twoEStr3112 = mallocInt(numDefine66);
let ztv33btConvexConcaveCollisionAlgorithm = mallocInt(numDefine28);
let zti33btConvexConcaveCollisionAlgorithm = mallocInt(numDefine12);
let zts33btConvexConcaveCollisionAlgorithm = mallocInt(numDefine36);
let zti30btCollisionAlgorithmCreateFunc = mallocInt(numDefine8);
let zts30btCollisionAlgorithmCreateFunc = mallocInt(numDefine33);
let ztvn23btConvexConvexAlgorithm10CreateFuncE = mallocInt(numDefine20);
let ztin23btConvexConvexAlgorithm10CreateFuncE = mallocInt(numDefine12);
let ztsn23btConvexConvexAlgorithm10CreateFuncE = mallocInt(numDefine40);
let ztv24btPerturbedContactResult = mallocInt(numDefine28);
let zti24btPerturbedContactResult = mallocInt(numDefine12);
let zts24btPerturbedContactResult = mallocInt(numDefine27);
let twoEStr115 = mallocInt(numDefine19);
let twoEStr4119 = mallocInt(numDefine49);
let twoEStr5120 = mallocInt(numDefine78);
let ztv23btConvexConvexAlgorithm = mallocInt(numDefine28);
let zti23btConvexConvexAlgorithm = mallocInt(numDefine12);
let zts23btConvexConvexAlgorithm = mallocInt(numDefine26);
let ztv31btConvexPlaneCollisionAlgorithm = mallocInt(numDefine28);
let zti31btConvexPlaneCollisionAlgorithm = mallocInt(numDefine12);
let zts31btConvexPlaneCollisionAlgorithm = mallocInt(numDefine34);
let ztvn31btConvexPlaneCollisionAlgorithm10CreateFuncE = mallocInt(numDefine20);
let ztin31btConvexPlaneCollisionAlgorithm10CreateFuncE = mallocInt(numDefine12);
let ztsn31btConvexPlaneCollisionAlgorithm10CreateFuncE = mallocInt(numDefine48);
let zti24btCollisionConfiguration = mallocInt(numDefine8);
let zts24btCollisionConfiguration = mallocInt(numDefine27);
let ztvn33btConvexConcaveCollisionAlgorithm10CreateFuncE = mallocInt(numDefine20);
let ztin33btConvexConcaveCollisionAlgorithm10CreateFuncE = mallocInt(numDefine12);
let ztsn33btConvexConcaveCollisionAlgorithm10CreateFuncE = mallocInt(numDefine50);
let ztvn33btConvexConcaveCollisionAlgorithm17SwappedCreateFuncE = mallocInt(numDefine20);
let ztin33btConvexConcaveCollisionAlgorithm17SwappedCreateFuncE = mallocInt(numDefine12);
let ztsn33btConvexConcaveCollisionAlgorithm17SwappedCreateFuncE = mallocInt(numDefine57);
let ztvn28btCompoundCollisionAlgorithm10CreateFuncE = mallocInt(numDefine20);
let ztin28btCompoundCollisionAlgorithm10CreateFuncE = mallocInt(numDefine12);
let ztsn28btCompoundCollisionAlgorithm10CreateFuncE = mallocInt(numDefine45);
let ztvn28btCompoundCollisionAlgorithm17SwappedCreateFuncE = mallocInt(numDefine20);
let ztin28btCompoundCollisionAlgorithm17SwappedCreateFuncE = mallocInt(numDefine12);
let ztsn28btCompoundCollisionAlgorithm17SwappedCreateFuncE = mallocInt(numDefine52);
let ztvn16btEmptyAlgorithm10CreateFuncE = mallocInt(numDefine20);
let ztin16btEmptyAlgorithm10CreateFuncE = mallocInt(numDefine12);
let ztsn16btEmptyAlgorithm10CreateFuncE = mallocInt(numDefine33);
let ztvn32btSphereSphereCollisionAlgorithm10CreateFuncE = mallocInt(numDefine20);
let ztin32btSphereSphereCollisionAlgorithm10CreateFuncE = mallocInt(numDefine12);
let ztsn32btSphereSphereCollisionAlgorithm10CreateFuncE = mallocInt(numDefine49);
let ztvn34btSphereTriangleCollisionAlgorithm10CreateFuncE = mallocInt(numDefine20);
let ztin34btSphereTriangleCollisionAlgorithm10CreateFuncE = mallocInt(numDefine12);
let ztsn34btSphereTriangleCollisionAlgorithm10CreateFuncE = mallocInt(numDefine51);
let ztvn26btBoxBoxCollisionAlgorithm10CreateFuncE = mallocInt(numDefine20);
let ztin26btBoxBoxCollisionAlgorithm10CreateFuncE = mallocInt(numDefine12);
let ztsn26btBoxBoxCollisionAlgorithm10CreateFuncE = mallocInt(numDefine43);
let twoEStr128 = mallocInt(numDefine12);
let twoEStr1129 = mallocInt(numDefine42);
let ztv31btDefaultCollisionConfiguration = mallocInt(numDefine36);
let zti31btDefaultCollisionConfiguration = mallocInt(numDefine12);
let zts31btDefaultCollisionConfiguration = mallocInt(numDefine34);
let ztv16btEmptyAlgorithm = mallocInt(numDefine28);
let zti16btEmptyAlgorithm = mallocInt(numDefine12);
let zts16btEmptyAlgorithm = mallocInt(numDefine19);
let ztv16btManifoldResult = mallocInt(numDefine28);
let twoEStr2149 = mallocInt(numDefine31);
let twoEStr3150 = mallocInt(numDefine12);
let twoEStr5152 = mallocInt(numDefine71);
let twoEStr155 = mallocInt(numDefine28);
let twoEStr1156 = mallocInt(numDefine73);
let twoEStr2157 = mallocInt(numDefine80);
let twoEStr3158 = mallocInt(numDefine15);
let ztv25btSimulationIslandManager = mallocInt(numDefine24);
let zti25btSimulationIslandManager = mallocInt(numDefine8);
let zts25btSimulationIslandManager = mallocInt(numDefine28);
let ztv32btSphereSphereCollisionAlgorithm = mallocInt(numDefine28);
let zti32btSphereSphereCollisionAlgorithm = mallocInt(numDefine12);
let zts32btSphereSphereCollisionAlgorithm = mallocInt(numDefine35);
let ztv34btSphereTriangleCollisionAlgorithm = mallocInt(numDefine28);
let zti34btSphereTriangleCollisionAlgorithm = mallocInt(numDefine12);
let zts34btSphereTriangleCollisionAlgorithm = mallocInt(numDefine37);
let ztv22SphereTriangleDetector = mallocInt(numDefine20);
let zti22SphereTriangleDetector = mallocInt(numDefine12);
let zts22SphereTriangleDetector = mallocInt(numDefine25);
let twoEStr173 = mallocInt(numDefine4);
let twoEStr2175 = mallocInt(numDefine61);
let ztv10btBoxShape = mallocInt(numDefine124);
let zti10btBoxShape = mallocInt(numDefine12);
let zts10btBoxShape = mallocInt(numDefine13);
let twoEStr181 = mallocInt(numDefine16);
let ztvzn22btBvhTriangleMeshShape14performRaycastEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback = mallocInt(numDefine20);
let ztizn22btBvhTriangleMeshShape14performRaycastEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback = mallocInt(numDefine12);
let ztszn22btBvhTriangleMeshShape14performRaycastEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback = mallocInt(numDefine104);
let ztvzn22btBvhTriangleMeshShape17performConvexcastEP18btTriangleCallbackRK9btVector3S4S4S4E21MyNodeOverlapCallback = mallocInt(numDefine20);
let ztizn22btBvhTriangleMeshShape17performConvexcastEP18btTriangleCallbackRK9btVector3S4S4S4E21MyNodeOverlapCallback = mallocInt(numDefine12);
let ztszn22btBvhTriangleMeshShape17performConvexcastEP18btTriangleCallbackRK9btVector3S4S4S4E21MyNodeOverlapCallback = mallocInt(numDefine113);
let ztvznk22btBvhTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback = mallocInt(numDefine20);
let ztiznk22btBvhTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback = mallocInt(numDefine12);
let ztsznk22btBvhTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback = mallocInt(numDefine110);
let twoEStr5186 = mallocInt(numDefine70);
let twoEStr6187 = mallocInt(numDefine49);
let twoEStr7188 = mallocInt(numDefine75);
let twoEStr8189 = mallocInt(numDefine24);
let ztv22btBvhTriangleMeshShape = mallocInt(numDefine88);
let zti22btBvhTriangleMeshShape = mallocInt(numDefine12);
let zts22btBvhTriangleMeshShape = mallocInt(numDefine25);
let zti19btTriangleMeshShape = mallocInt(numDefine12);
let zts19btTriangleMeshShape = mallocInt(numDefine22);
let zti14btConcaveShape = mallocInt(numDefine12);
let zts14btConcaveShape = mallocInt(numDefine17);
let twoEStr194 = mallocInt(numDefine13);
let twoEStr4198 = mallocInt(numDefine72);
let twoEStr6199 = mallocInt(numDefine19);
let ztv14btCapsuleShape = mallocInt(numDefine92);
let zti14btCapsuleShape = mallocInt(numDefine12);
let zts14btCapsuleShape = mallocInt(numDefine17);
let twoEStr200 = mallocInt(numDefine21);
let ztv14btConcaveShape = mallocInt(numDefine72);
let twoEStr219 = mallocInt(numDefine7);
let twoEStr3222 = mallocInt(numDefine70);
let ztv17btConvexHullShape = mallocInt(numDefine120);
let zti17btConvexHullShape = mallocInt(numDefine12);
let zts17btConvexHullShape = mallocInt(numDefine20);
let zti34btPolyhedralConvexAabbCachingShape = mallocInt(numDefine12);
let zts34btPolyhedralConvexAabbCachingShape = mallocInt(numDefine37);
let twoEStr5223 = mallocInt(numDefine19);
let twoEStr6224 = mallocInt(numDefine22);
let twoEStr6232 = mallocInt(numDefine19);
let ztv13btConvexShape = mallocInt(numDefine92);
let twoEStr6249 = mallocInt(numDefine13);
let twoEStr7250 = mallocInt(numDefine66);
let ztvzn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4E20NodeTriangleCallback = mallocInt(numDefine20);
let ztizn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4E20NodeTriangleCallback = mallocInt(numDefine12);
let ztszn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4E20NodeTriangleCallback = mallocInt(numDefine91);
let ztvzn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4E29QuantizedNodeTriangleCallback = mallocInt(numDefine20);
let ztizn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4E29QuantizedNodeTriangleCallback = mallocInt(numDefine12);
let ztszn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4E29QuantizedNodeTriangleCallback = mallocInt(numDefine100);
let twoEStr10306 = mallocInt(numDefine67);
let twoEStr18314 = mallocInt(numDefine36);
let twoEStr19315 = mallocInt(numDefine48);
let twoEStr20316 = mallocInt(numDefine17);
let ztv14btOptimizedBvh = mallocInt(numDefine40);
let zti14btOptimizedBvh = mallocInt(numDefine12);
let zts14btOptimizedBvh = mallocInt(numDefine17);
let twoEStr7331 = mallocInt(numDefine74);
let zgvzn34btPolyhedralConvexAabbCachingShape15recalcLocalAabbEvE11Directions = mallocInt(numDefine8);
let zzn34btPolyhedralConvexAabbCachingShape15recalcLocalAabbEvE11Directions = mallocInt(numDefine96);
let twoEStr342 = mallocInt(numDefine7);
let ztv13btSphereShape = mallocInt(numDefine92);
let zti13btSphereShape = mallocInt(numDefine12);
let zts13btSphereShape = mallocInt(numDefine16);
let twoEStr349 = mallocInt(numDefine15);
let twoEStr1350 = mallocInt(numDefine27);
let twoEStr3352 = mallocInt(numDefine76);
let twoEStr5354 = mallocInt(numDefine20);
let twoEStr6355 = mallocInt(numDefine44);
let twoEStr7356 = mallocInt(numDefine15);
let twoEStr8357 = mallocInt(numDefine28);
let twoEStr9358 = mallocInt(numDefine61);
let ztv23btStridingMeshInterface = mallocInt(numDefine68);
let zti23btStridingMeshInterface = mallocInt(numDefine8);
let zts23btStridingMeshInterface = mallocInt(numDefine26);
let ztv31btInternalTriangleIndexCallback = mallocInt(numDefine20);
let ztv18btTriangleCallback = mallocInt(numDefine20);
let twoEStr367 = mallocInt(numDefine26);
let twoEStr1368 = mallocInt(numDefine79);
let ztv26btTriangleIndexVertexArray = mallocInt(numDefine68);
let zti26btTriangleIndexVertexArray = mallocInt(numDefine12);
let zts26btTriangleIndexVertexArray = mallocInt(numDefine29);
let twoEStr372 = mallocInt(numDefine13);
let ztv21SupportVertexCallback = mallocInt(numDefine20);
let zti21SupportVertexCallback = mallocInt(numDefine12);
let zts21SupportVertexCallback = mallocInt(numDefine24);
let ztvznk19btTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4E16FilteredCallback = mallocInt(numDefine20);
let ztiznk19btTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4E16FilteredCallback = mallocInt(numDefine12);
let ztsznk19btTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4E16FilteredCallback = mallocInt(numDefine102);
let twoEStr3375 = mallocInt(numDefine72);
let ztv19btTriangleMeshShape = mallocInt(numDefine80);
let ztv16btPointCollector = mallocInt(numDefine28);
let zti16btPointCollector = mallocInt(numDefine12);
let zts16btPointCollector = mallocInt(numDefine19);
let ztv27btContinuousConvexCollision = mallocInt(numDefine20);
let zti27btContinuousConvexCollision = mallocInt(numDefine12);
let zts27btContinuousConvexCollision = mallocInt(numDefine30);
let zti12btConvexCast = mallocInt(numDefine8);
let zts12btConvexCast = mallocInt(numDefine15);
let ztv12btConvexCast = mallocInt(numDefine20);
let ztv15btGjkConvexCast = mallocInt(numDefine20);
let zti15btGjkConvexCast = mallocInt(numDefine12);
let zts15btGjkConvexCast = mallocInt(numDefine18);
let zzn12gjkepa2Impl3GJK13projectoriginERK9btVector3S3S3PfRjE4imd3 = mallocInt(numDefine12);
let zzn12gjkepa2Impl3EPA6expandEjPNS3GJK3sSVEPNS05sFaceEjRNS08sHorizonEE4i2m3 = mallocInt(numDefine12);
let ztv30btGjkEpaPenetrationDepthSolver = mallocInt(numDefine20);
let zti30btGjkEpaPenetrationDepthSolver = mallocInt(numDefine12);
let zts30btGjkEpaPenetrationDepthSolver = mallocInt(numDefine33);
let gNumDeepPenetrationChecks = mallocInt(numDefine4);
let ztv17btGjkPairDetector = mallocInt(numDefine20);
let zti17btGjkPairDetector = mallocInt(numDefine12);
let zts17btGjkPairDetector = mallocInt(numDefine20);
let gNumGjkChecks = mallocInt(numDefine4);
let twoEStr425 = mallocInt(numDefine39);
let twoEStr1426 = mallocInt(numDefine71);
let twoEStr2427 = mallocInt(numDefine18);
let twoEStr3428 = mallocInt(numDefine75);
let gContactBreakingThreshold = mallocInt(numDefine4);
let twoEStr434 = mallocInt(numDefine52);
let twoEStr3437 = mallocInt(numDefine78);
let twoEStr4438 = mallocInt(numDefine50);
let ztv28btTriangleConvexcastCallback = mallocInt(numDefine24);
let ztv22btSubsimplexConvexCast = mallocInt(numDefine20);
let zti22btSubsimplexConvexCast = mallocInt(numDefine12);
let zts22btSubsimplexConvexCast = mallocInt(numDefine25);
let twoEStr457 = mallocInt(numDefine16);
let twoEStr1458 = mallocInt(numDefine80);
let ztvn16btCollisionWorld27ClosestConvexResultCallbackE = mallocInt(numDefine24);
let ztin16btCollisionWorld27ClosestConvexResultCallbackE = mallocInt(numDefine12);
let ztsn16btCollisionWorld27ClosestConvexResultCallbackE = mallocInt(numDefine50);
let twoEStr36 = mallocInt(numDefine51);
let twoEStr239 = mallocInt(numDefine26);
let ztv21btConeTwistConstraint = mallocInt(numDefine52);
let zti21btConeTwistConstraint = mallocInt(numDefine12);
let zts21btConeTwistConstraint = mallocInt(numDefine24);
let twoEStr1340 = mallocInt(numDefine37);
let twoEStr24 = mallocInt(numDefine74);
let twoEStr442 = mallocInt(numDefine37);
let twoEStr543 = mallocInt(numDefine37);
let twoEStr846 = mallocInt(numDefine24);
let twoEStr947 = mallocInt(numDefine66);
let twoEStr1149 = mallocInt(numDefine30);
let twoEStr29 = mallocInt(numDefine27);
let ztv17btHingeConstraint = mallocInt(numDefine52);
let zti17btHingeConstraint = mallocInt(numDefine12);
let zts17btHingeConstraint = mallocInt(numDefine20);
let twoEStr130 = mallocInt(numDefine34);
let twoEStr231 = mallocInt(numDefine70);
let twoEStr332 = mallocInt(numDefine34);
let twoEStr433 = mallocInt(numDefine34);
let gNumSplitImpulseRecoveries = mallocInt(numDefine4);
let zti18btConstraintSolver = mallocInt(numDefine8);
let zts18btConstraintSolver = mallocInt(numDefine21);
let ztv35btSequentialImpulseConstraintSolver = mallocInt(numDefine48);
let zti35btSequentialImpulseConstraintSolver = mallocInt(numDefine12);
let zts35btSequentialImpulseConstraintSolver = mallocInt(numDefine38);
let zgvzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed = mallocInt(numDefine8);
let zzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed = mallocInt(numDefine608);
let twoEStr248 = mallocInt(numDefine27);
let twoEStr34955 = mallocInt(numDefine54);
let twoEStr450 = mallocInt(numDefine11);
let twoEStr551 = mallocInt(numDefine7);
let twoEStr652 = mallocInt(numDefine88);
let twoEStr753 = mallocInt(numDefine10);
let twoEStr854 = mallocInt(numDefine34);
let twoEStr955 = mallocInt(numDefine3);
let twoEStr1056 = mallocInt(numDefine29);
let twoEStr1157 = mallocInt(numDefine24);
let twoEStr76 = mallocInt(numDefine22);
let zti23btDiscreteDynamicsWorld = mallocInt(numDefine12);
let zts23btDiscreteDynamicsWorld = mallocInt(numDefine26);
let zti15btDynamicsWorld = mallocInt(numDefine12);
let zts15btDynamicsWorld = mallocInt(numDefine18);
let ztin25btSimulationIslandManager14IslandCallbackE = mallocInt(numDefine8);
let ztsn25btSimulationIslandManager14IslandCallbackE = mallocInt(numDefine46);
let ztv34btClosestNotMeConvexResultCallback = mallocInt(numDefine24);
let zti34btClosestNotMeConvexResultCallback = mallocInt(numDefine12);
let zts34btClosestNotMeConvexResultCallback = mallocInt(numDefine37);
let ztvzn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoE27InplaceSolverIslandCallback = mallocInt(numDefine20);
let ztizn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoE27InplaceSolverIslandCallback = mallocInt(numDefine12);
let ztszn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoE27InplaceSolverIslandCallback = mallocInt(numDefine99);
let twoEStr87 = mallocInt(numDefine26);
let twoEStr188 = mallocInt(numDefine27);
let twoEStr289 = mallocInt(numDefine14);
let twoEStr794 = mallocInt(numDefine20);
let twoEStr895 = mallocInt(numDefine20);
let gNumClampedCcdMotions = mallocInt(numDefine4);
let twoEStr996 = mallocInt(numDefine17);
let twoEStr1097 = mallocInt(numDefine22);
let twoEStr1198 = mallocInt(numDefine29);
let twoEStr1299 = mallocInt(numDefine15);
let twoEStr13100 = mallocInt(numDefine5);
let twoEStr1461 = mallocInt(numDefine68);
let twoEStr1562 = mallocInt(numDefine24);
let twoEStr16101 = mallocInt(numDefine15);
let ztv15btDynamicsWorld = mallocInt(numDefine140);
let ztv23btDiscreteDynamicsWorld = mallocInt(numDefine180);
let zl8uniqueId = mallocInt(numDefine4);
let ztv11btRigidBody = mallocInt(numDefine36);
let zti11btRigidBody = mallocInt(numDefine12);
let zts11btRigidBody = mallocInt(numDefine14);
let twoEStr4144 = mallocInt(numDefine21);
let gDisableDeactivation = mallocInt(1);
let gNumAlignedAllocs = mallocInt(numDefine4);
let gNumAlignedFree = mallocInt(numDefine4);
let zn15CProfileManager12FrameCounterE = mallocInt(numDefine4);
let zn15CProfileManager4RootE = mallocInt(numDefine32);
let zl13gProfileClock2E0 = mallocInt(numDefine4);
let zn15CProfileManager11CurrentNodeE = mallocInt(numDefine4);
let twoEStr729 = mallocInt(numDefine5);
let zn4RwL12RwCatlistE2E0 = mallocInt(numDefine4);
let zn4RwL12RwCatlistE2E1 = mallocInt(numDefine4);
let zn4RwL12RwCatlistE2E2 = mallocInt(numDefine4);
let llvm2EEh2ECatch2EAll2EValue = mallocInt(numDefine4);
let ztin4Rw10RwFacetE = mallocInt(numDefine12);
let ztsn4Rw10RwFacetE = mallocInt(numDefine20);
let ztin4Rw17RwSynchronizedE = mallocInt(numDefine8);
let ztsn4Rw17RwSynchronizedE = mallocInt(numDefine27);
let twoEStr4131 = mallocInt(numDefine10);
let twoEStr15132 = mallocInt(numDefine21);
let twoEStr26 = mallocInt(1);
let zn4RwL13RwWhatBufE = mallocInt(numDefine256);
let zn4RwL16RwWhatRefcntE = mallocInt(numDefine4);
let twoEStr3133 = mallocInt(numDefine16);
let twoEStr47 = mallocInt(numDefine25);
let twoEStr5134 = mallocInt(numDefine18);
let zzn4RwL13RwVfmtwhatEPcjiS0E7Fname = mallocInt(numDefine4);
let zzn4RwL13RwVfmtwhatEPcjiS0E6buffer = mallocInt(numDefine11);
let twoEStr7136 = mallocInt(numDefine3);
let zzn4RwL13RwVfmtwhatEPcjiS0E8Catset = mallocInt(numDefine4);
let zzn4RwL13RwVfmtwhatEPcjiS0E4msgs = mallocInt(numDefine32);
let zzn4RwL13RwVfmtwhatEPcjiS0E5Cat = mallocInt(numDefine4);
let zzn4Rw10RwThrowEizE6errors = mallocInt(numDefine100);
let twoEStr8137 = mallocInt(numDefine26);
let twoEStr9138 = mallocInt(numDefine18);
let twoEStr10139 = mallocInt(numDefine29);
let twoEStr11140 = mallocInt(numDefine33);
let twoEStr12141 = mallocInt(numDefine17);
let twoEStr138142 = mallocInt(numDefine20);
let twoEStr14143 = mallocInt(numDefine21);
let twoEStr159144 = mallocInt(numDefine25);
let twoEStr16145 = mallocInt(numDefine51);
let twoEStr17146 = mallocInt(numDefine47);
let twoEStr18147 = mallocInt(numDefine22);
let twoEStr19148 = mallocInt(numDefine44);
let twoEStr20149 = mallocInt(numDefine23);
let twoEStr21150 = mallocInt(numDefine24);
let twoEStr22151 = mallocInt(numDefine39);
let twoEStr23152 = mallocInt(numDefine38);
let twoEStr24153 = mallocInt(numDefine38);
let twoEStr25154 = mallocInt(numDefine29);
let twoEStr2610 = mallocInt(numDefine44);
let twoEStr27 = mallocInt(numDefine30);
let twoEStr28155 = mallocInt(numDefine40);
let twoEStr29156 = mallocInt(numDefine26);
let twoEStr30 = mallocInt(numDefine27);
let twoEStr31 = mallocInt(numDefine30);
let twoEStr32157 = mallocInt(numDefine32);
let twoEStr33 = mallocInt(numDefine11);
let twoEStr134 = mallocInt(numDefine9);
let twoEStr235 = mallocInt(numDefine12);
let twoEStr336 = mallocInt(numDefine11);
let twoEStr437 = mallocInt(numDefine8);
let ztvn4Rw10RwFacetE = mallocInt(numDefine16);
let twoEStr538 = mallocInt(numDefine2);
let zzn4Rw10RwFacet9CManageEPS0NS013CFacetTypeEPKcPFS1JS4EE12nStdFacets = mallocInt(numDefine4);
let zzn4Rw10RwFacet9CManageEPS0NS013CFacetTypeEPKcPFS1JS4EE10stdFacets = mallocInt(numDefine4);
let zzn4Rw10RwFacet9CManageEPS0NS013CFacetTypeEPKcPFS1JS4EE13stdFacetBuf = mallocInt(numDefine1664);
let zzn4Rw10RwFacet9CManageEPS0NS013CFacetTypeEPKcPFS1JS4EE17stdFacetBufsize = mallocInt(numDefine4);
let zzn4Rw10RwFacetD4EvE9destroyed = mallocInt(numDefine24);
let zn4Rw9RwCatsE = mallocInt(numDefine72);
let twoEStr785 = mallocInt(numDefine2);
let zzn4Rw11RwLocale9CManageEPS0PKcE6global = mallocInt(numDefine4);
let zzn4Rw11RwLocale9CManageEPS0PKcE5ginit = mallocInt(numDefine4);
let zzn4Rw11RwLocale9CManageEPS0PKcE9nLocales = mallocInt(numDefine4);
let zzn4Rw11RwLocale9CManageEPS0PKcE7locales = mallocInt(numDefine4);
let zzn4Rw11RwLocale9CManageEPS0PKcE10localeBuf = mallocInt(numDefine32);
let zzn4Rw11RwLocale9CManageEPS0PKcE14localeBufsize = mallocInt(numDefine4);
let zzn4Rw11RwLocale9CManageEPS0PKcE7classic = mallocInt(numDefine4);
let zzn4Rw11RwLocale9CManageEPS0PKcE12classicBody = mallocInt(numDefine172);
let zn4RwL22RwClassicOnceInitE2E02EB = mallocInt(1);
let zn4RwL12RwClassicE = mallocInt(numDefine4);
let twoEStr292167 = mallocInt(numDefine4);
let twoEStr10100175 = mallocInt(numDefine29);
let twoEStr12102177 = mallocInt(numDefine33);
let zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE4init2EB = mallocInt(1);
let zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE8catalogs = mallocInt(numDefine4);
let zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE11catalogBuf = mallocInt(numDefine64);
let zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE15catalogBufsize = mallocInt(numDefine4);
let zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE10nCatalogs = mallocInt(numDefine4);
let zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE11largestCat = mallocInt(numDefine4);
let twoEStr115180 = mallocInt(numDefine27);
let twoEStr1116181 = mallocInt(numDefine25);
let twoEStr2131 = mallocInt(numDefine2);
let twoEStr4133 = mallocInt(numDefine2);
let zzn4Rw16RwLocaleNameEiPKcRNS14RwPodArrayIcLj256EEEE11localeRoot = mallocInt(numDefine259);
let znss11CNullRefE = mallocInt(numDefine16);
let ztvst8messagesIcE = mallocInt(numDefine28);
let ztist8messagesIcE = mallocInt(numDefine32);
let ztsst8messagesIcE = mallocInt(numDefine15);
let ztist13messagesBase = mallocInt(numDefine8);
let ztsst13messagesBase = mallocInt(numDefine18);
let twoEStr2360 = mallocInt(numDefine31);
let twoEStr3361 = mallocInt(numDefine48);
let twoEStr4362 = mallocInt(numDefine31);
let ztvst9typeInfo = mallocInt(numDefine24);
let ztist9typeInfo = mallocInt(numDefine8);
let ztsst9typeInfo = mallocInt(numDefine13);
let sMaxMemory = mallocInt(numDefine4);
let sCurrentMemory = mallocInt(numDefine4);
let blockNull = mallocInt(numDefine16);
let twoEStr643 = mallocInt(numDefine57);
let twoEStr1648 = mallocInt(numDefine3);
let twoEStr4651 = mallocInt(numDefine4);
let twoEStr5652 = mallocInt(numDefine4);
let myCtype = mallocInt(numDefine1028);
let zl8nextRand = mallocInt(numDefine4);
let twoEStr7654 = mallocInt(numDefine4);
let twoEStr9655 = mallocInt(numDefine4);
let zl8padLine = mallocInt(numDefine64);
let zl10strtokPos = mallocInt(numDefine4);
let zti14CFileInterface = mallocInt(numDefine8);
let zts14CFileInterface = mallocInt(numDefine17);
let ztv11CFileSystem = mallocInt(numDefine44);
let zti11CFileSystem = mallocInt(numDefine12);
let zts11CFileSystem = mallocInt(numDefine14);
let zl13sFileStdout = mallocInt(numDefine4);
let ztv7CFileLS = mallocInt(numDefine44);
let zti7CFileLS = mallocInt(numDefine12);
let zts7CFileLS = mallocInt(numDefine9);
let ztv10CFileCloud = mallocInt(numDefine44);
let zti10CFileCloud = mallocInt(numDefine12);
let zts10CFileCloud = mallocInt(numDefine13);
let zl10sASockets = mallocInt(numDefine62336);
let ztv11CFileStdout = mallocInt(numDefine44);
let zti11CFileStdout = mallocInt(numDefine12);
let zts11CFileStdout = mallocInt(numDefine14);
let twoEStr31677 = mallocInt(numDefine4);
let twoEStr32678 = mallocInt(numDefine4);
let twoEStr33679 = mallocInt(numDefine5);
let twoEStr34680 = mallocInt(numDefine8);
let twoEStr35681 = mallocInt(numDefine53);
let twoEStr37683 = mallocInt(numDefine4);
let twoEStr38684 = mallocInt(numDefine7);
let zn12mandreelB64L9b64CharsE = mallocInt(numDefine65);
let zn12mandreelB64L11b64IndexesE = mallocInt(numDefine256);
let zl25sMandreelInternalWidth = mallocInt(numDefine4);
let zl26sMandreelInternalHeight = mallocInt(numDefine4);
let gMsgcallback = mallocInt(numDefine4);
let zl24gPFirstTextureAsyncInfo = mallocInt(numDefine4);
let zl17gApPackFileNames = mallocInt(numDefine1024);
let zgvz21MandreelGetTickCountE7sFirst = mallocInt(numDefine8);
let zz21MandreelGetTickCountE7sFirst = mallocInt(numDefine8);
let zz29MandreelInternalPreupdateE8sBfirst2EB = mallocInt(1);
let twoEStr779 = mallocInt(numDefine13);
let twoEStr3782 = mallocInt(numDefine13);
let twoEStr4783 = mallocInt(numDefine37);
let twoEStr5784 = mallocInt(numDefine12);
let twoEStr6785 = mallocInt(numDefine17);
let zz24MandreelInternalInitE54s723478567MandreelMandreelInternalSetResolution = mallocInt(numDefine4);
let zz24MandreelInternalInitE56s723478567MandreelIMandreelTextureAsyncIsCompressed = mallocInt(numDefine4);
let zz24MandreelInternalInitE57s723478567MandreelIMandreelTextureAsyncGetPackOffset = mallocInt(numDefine4);
let zz24MandreelInternalInitE29s723478567MandreelResize = mallocInt(numDefine4);
let zz24MandreelInternalInitE48s723478567MandreelImandreelRestoreGlcontext = mallocInt(numDefine4);
let zz24MandreelInternalInitE46s723478567MandreelImandreelViewportResize = mallocInt(numDefine4);
let ztvn10Cxxabiv120SiClassTypeInfoE = mallocInt(numDefine40);
let ztin10Cxxabiv120SiClassTypeInfoE = mallocInt(numDefine12);
let ztsn10Cxxabiv120SiClassTypeInfoE = mallocInt(numDefine37);
let ztin10Cxxabiv117ClassTypeInfoE = mallocInt(numDefine12);
let ztsn10Cxxabiv117ClassTypeInfoE = mallocInt(numDefine34);
let ztvn10Cxxabiv117ClassTypeInfoE = mallocInt(numDefine40);
let ztvn10Cxxabiv121VmiClassTypeInfoE = mallocInt(numDefine40);
let ztin10Cxxabiv121VmiClassTypeInfoE = mallocInt(numDefine12);
let ztsn10Cxxabiv121VmiClassTypeInfoE = mallocInt(numDefine38);
let zl11gAChannels = mallocInt(numDefine9344);
let zl7gBInit2EB = mallocInt(1);
let twoEStr221 = mallocInt(numDefine8);
let twoEStr1222 = mallocInt(numDefine21);
let zl21gPFirstSoundDuration = mallocInt(numDefine4);
let twoEStr3224 = mallocInt(numDefine71);
let twoEStr4225 = mallocInt(numDefine8);
let zl15gIFreeChannels = mallocInt(numDefine4);
let zl15gAFreeChannels = mallocInt(numDefine128);
let zl6gBLog = mallocInt(1);
let twoEStr12233 = mallocInt(numDefine5);
let twoEStr22243 = mallocInt(numDefine21);
let twoEStr24245 = mallocInt(numDefine86);
let twoEStr26247 = mallocInt(numDefine8);
let twoEStr27248 = mallocInt(numDefine4);
let twoEStr28249 = mallocInt(numDefine60);
let twoEStr29250 = mallocInt(numDefine10);
let twoEStr30251 = mallocInt(numDefine3);
let twoEStr31252 = mallocInt(numDefine75);
let twoEStr32253 = mallocInt(numDefine5);
let twoEStr33254 = mallocInt(numDefine4);
let twoEStr34255 = mallocInt(numDefine9);
let twoEStr35256 = mallocInt(numDefine22);
let zzl32MandreelInitTcpSocketLibrayvE47s723478567MandreelMandreelFlashTcpOnError = mallocInt(numDefine4);
let zl13sFifoErrors = mallocInt(numDefine24);
let zn5myGlL9mContextE = mallocInt(numDefine324);
let llvm2EGlobalCtors = mallocInt(numDefine40);
let llvm2EGlobalDtors = mallocInt(numDefine56);
let llvm2EUsed = mallocInt(numDefine300);

let myHeapNewPos: number = 0;

class CMalloc {
  static malloc(): void {
    gStackPointer;
    argTestLocal;
    llvmDoubleAddr;
    llvmErrno;
    zgvzn11btMatrix3x311getIdentityEvE14identityMatrix;
    zgvzn11btTransform11getIdentityEvE17identityTransform;
    landscape02Vtx;
    ztin16btCollisionWorld17RayResultCallbackE;
    ztsn16btCollisionWorld17RayResultCallbackE;
    ztvn16btCollisionWorld24ClosestRayResultCallbackE;
    ztin16btCollisionWorld24ClosestRayResultCallbackE;
    ztsn16btCollisionWorld24ClosestRayResultCallbackE;
    zti13btMotionState;
    zts13btMotionState;
    ztv20btDefaultMotionState;
    zti20btDefaultMotionState;
    zts20btDefaultMotionState;
    zti17btTypedConstraint;
    zts17btTypedConstraint;
    zti13btTypedObject;
    zts13btTypedObject;
    ztv7RagDoll;
    zti7RagDoll;
    zts7RagDoll;
    ztv13BenchmarkDemo;
    zti13BenchmarkDemo;
    zts13BenchmarkDemo;
    zti15DemoApplication;
    zts15DemoApplication;
    zl10raycastBar;
    twoEStr3;
    twoEStr4;
    twoEStr5;
    twoEStr6;
    twoEStr7;
    zl7TaruVtx;
    landscapeVtx;
    landscape01Vtx;
    landscape03Vtx;
    landscape04Vtx;
    landscape05Vtx;
    landscape06Vtx;
    landscape07Vtx;
    landscape08Vtx;
    landscapeVtxCount;
    landscapeIdx;
    landscape01Idx;
    landscape02Idx;
    landscape03Idx;
    landscape04Idx;
    landscape05Idx;
    landscape06Idx;
    landscape07Idx;
    landscape08Idx;
    landscapeIdxCount;
    zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E02E02E0;
    zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E12E02E1;
    zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E22E02E2;
    zzn11btTransform11getIdentityEvE17identityTransform;
    ztv14BenchmarkDemo4;
    zti14BenchmarkDemo4;
    zts14BenchmarkDemo4;
    zl14benchmarkDemo4;
    zti21btBroadphaseInterface;
    zts21btBroadphaseInterface;
    zti25btOverlappingPairCallback;
    zts25btOverlappingPairCallback;
    zti22btOverlappingPairCache;
    zts22btOverlappingPairCache;
    ztv15btNullPairCache;
    zti15btNullPairCache;
    zts15btNullPairCache;
    twoEStr11;
    twoEStr112;
    twoEStr213;
    twoEStr314;
    ztv20btAxisSweep3InternalItE;
    zti20btAxisSweep3InternalItE;
    zts20btAxisSweep3InternalItE;
    ztv12btAxisSweep3;
    zti12btAxisSweep3;
    zts12btAxisSweep3;
    ztv20btCollisionAlgorithm;
    zti20btCollisionAlgorithm;
    zts20btCollisionAlgorithm;
    ztin6btDbvt8ICollideE;
    ztsn6btDbvt8ICollideE;
    twoEStr1118;
    twoEStr22;
    ztv18btDbvtTreeCollider;
    zti18btDbvtTreeCollider;
    zts18btDbvtTreeCollider;
    ztv19BroadphaseRayTester;
    zti19BroadphaseRayTester;
    zts19BroadphaseRayTester;
    ztv20BroadphaseAabbTester;
    zti20BroadphaseAabbTester;
    zts20BroadphaseAabbTester;
    twoEStr18;
    ztv16btDbvtBroadphase;
    zti16btDbvtBroadphase;
    zts16btDbvtBroadphase;
    ztv12btDispatcher;
    zti12btDispatcher;
    zts12btDispatcher;
    zti21btNodeOverlapCallback;
    zts21btNodeOverlapCallback;
    twoEStr10;
    twoEStr212;
    twoEStr313;
    twoEStr414;
    twoEStr515;
    twoEStr616;
    twoEStr717;
    twoEStr820;
    twoEStr9;
    gOverlappingPairs;
    zti17btOverlapCallback;
    zts17btOverlapCallback;
    ztvzn28btHashedOverlappingPairCache19cleanProxyFromPairsEP17btBroadphaseProxyP12btDispatcherE17CleanPairCallback;
    ztizn28btHashedOverlappingPairCache19cleanProxyFromPairsEP17btBroadphaseProxyP12btDispatcherE17CleanPairCallback;
    ztszn28btHashedOverlappingPairCache19cleanProxyFromPairsEP17btBroadphaseProxyP12btDispatcherE17CleanPairCallback;
    ztvzn28btHashedOverlappingPairCache37removeOverlappingPairsContainingProxyEP17btBroadphaseProxyP12btDispatcherE18RemovePairCallback;
    ztizn28btHashedOverlappingPairCache37removeOverlappingPairsContainingProxyEP17btBroadphaseProxyP12btDispatcherE18RemovePairCallback;
    ztszn28btHashedOverlappingPairCache37removeOverlappingPairsContainingProxyEP17btBroadphaseProxyP12btDispatcherE18RemovePairCallback;
    gRemovePairs;
    ztv28btHashedOverlappingPairCache;
    zti28btHashedOverlappingPairCache;
    zts28btHashedOverlappingPairCache;
    twoEStr121;
    gAddedPairs;
    twoEStr222;
    twoEStr323;
    twoEStr424;
    twoEStr525;
    twoEStr626;
    twoEStr727;
    gFindPairs;
    twoEStr32;
    twoEStr133;
    twoEStr234;
    twoEStr335;
    ztv14btQuantizedBvh;
    zti14btQuantizedBvh;
    zts14btQuantizedBvh;
    twoEStr537;
    twoEStr638;
    twoEStr739;
    twoEStr941;
    twoEStr1143;
    maxIterations;
    twoEStr1844;
    twoEStr1921;
    twoEStr21;
    twoEStr2246;
    ztv30btActivatingCollisionAlgorithm;
    zti30btActivatingCollisionAlgorithm;
    zts30btActivatingCollisionAlgorithm;
    twoEStr59;
    twoEStr160;
    ztv26btBoxBoxCollisionAlgorithm;
    zti26btBoxBoxCollisionAlgorithm;
    zts26btBoxBoxCollisionAlgorithm;
    zti36btDiscreteCollisionDetectorInterface;
    zts36btDiscreteCollisionDetectorInterface;
    ztv16btBoxBoxDetector;
    zti16btBoxBoxDetector;
    zts16btBoxBoxDetector;
    twoEStr65;
    twoEStr166;
    gNumManifold;
    ztin36btDiscreteCollisionDetectorInterface6ResultE;
    ztsn36btDiscreteCollisionDetectorInterface6ResultE;
    ztv23btCollisionPairCallback;
    zti23btCollisionPairCallback;
    zts23btCollisionPairCallback;
    twoEStr169;
    twoEStr270;
    twoEStr371;
    twoEStr472;
    twoEStr573;
    ztv21btCollisionDispatcher;
    zti21btCollisionDispatcher;
    zts21btCollisionDispatcher;
    twoEStr674;
    twoEStr775;
    twoEStr876;
    twoEStr977;
    ztv17btCollisionObject;
    zti17btCollisionObject;
    zts17btCollisionObject;
    twoEStr78;
    ztin16btCollisionWorld20ConvexResultCallbackE;
    ztsn16btCollisionWorld20ConvexResultCallbackE;
    zti30btConvexPenetrationDepthSolver;
    zts30btConvexPenetrationDepthSolver;
    ztvn12btConvexCast10CastResultE;
    ztin12btConvexCast10CastResultE;
    ztsn12btConvexCast10CastResultE;
    ztvzn16btCollisionWorld13rayTestSingleERK11btTransformS2P17btCollisionObjectPK16btCollisionShapeS2RNS17RayResultCallbackEE15LocalInfoAdder2;
    ztizn16btCollisionWorld13rayTestSingleERK11btTransformS2P17btCollisionObjectPK16btCollisionShapeS2RNS17RayResultCallbackEE15LocalInfoAdder2;
    ztszn16btCollisionWorld13rayTestSingleERK11btTransformS2P17btCollisionObjectPK16btCollisionShapeS2RNS17RayResultCallbackEE15LocalInfoAdder2;
    ztvzn16CollsionQuerySingObjectPK;
    ztizn16btCollisionWorldCollisionShape;
    ztszn16btConvexResultLocalInfoAdder;
    zti24btBroadphaseAabbCallback;
    zts24btBroadphaseAabbCallback;
    zti23btBroadphaseRayCallback;
    zts23btBroadphaseRayCallback;
    ztv17DebugDrawcallback;
    zti17DebugDrawcallback;
    zts17DebugDrawcallback;
    zti18btTriangleCallback;
    zts18btTriangleCallback;
    zti31btInternalTriangleIndexCallback;
    zts31btInternalTriangleIndexCallback;
    ztv16btCollisionWorld;
    zti16btCollisionWorld;
    zts16btCollisionWorld;
    zti16btManifoldResult;
    zts16btManifoldResult;
    ztv21btSingleSweepCallback;
    zti21btSingleSweepCallback;
    zts21btSingleSweepCallback;
    ztv19btSingleRayCallback;
    zti19btSingleRayCallback;
    zts19btSingleRayCallback;
    twoEStr382;
    twoEStr483;
    twoEStr584;
    twoEStr685;
    twoEStr786;
    twoEStr887;
    twoEStr988;
    ztvzn16CollsionQuerySingConvex;
    ztizn16btCollisionTransformConvexcastCallback0;
    ztszn16btCollisionQuerySingleShapeRK11;
    zti28btTriangleConvexcastCallback;
    zts28btTriangleConvexcastCallback;
    ztvzn16CollsionQuery;
    ztizn16btCollisionWorld17objectQuerySing;
    ztszn16btCollisionWorld17object;
    ztvzn16CollsionTestCallback0;
    ztizn16btCollisionWorld13rayObjectPK16bt;
    ztszn16btCollisionObjectPK;
    zti25btTriangleRaycastCallback;
    zts25btTriangleRaycastCallback;
    ztvzn16CollsionTestERK;
    ztizn16btCollisionWorld13rayTestSingle;
    ztszn16btCollisionWorld;
    twoEStr1089;
    twoEStr1190;
    twoEStr1291;
    twoEStr1392;
    twoEStr1493;
    zzn16btCollisionWorld16updateSingleAabbEP17btCollisionObjectE8reportMe2EB;
    twoEStr1594;
    twoEStr1695;
    twoEStr1796;
    twoEStr1897;
    twoEStr1998;
    ztv22btCompoundLeafCallback;
    zti22btCompoundLeafCallback;
    zts22btCompoundLeafCallback;
    twoEStr99;
    twoEStr1100;
    twoEStr2101;
    twoEStr3102;
    twoEStr4103;
    twoEStr5104;
    twoEStr6105;
    twoEStr7106;
    ztv28btCompoundCollisionAlgorithm;
    zti28btCompoundCollisionAlgorithm;
    zts28btCompoundCollisionAlgorithm;
    twoEStr109;
    ztv24btConvexTriangleCallback;
    zti24btConvexTriangleCallback;
    zts24btConvexTriangleCallback;
    zn33btCollisionObjectS1RK;
    ztizn33btConvexConcave;
    ztszn33btConvex;
    ztv15btTriangleShape;
    zti15btTriangleShape;
    zts15btTriangleShape;
    zti23btPolyhedralConvexShape;
    zts23btPolyhedralConvexShape;
    zti21btConvexInternalShape;
    zts21btConvexInternalShape;
    zti13btConvexShape;
    zts13btConvexShape;
    zti16btCollisionShape;
    zts16btCollisionShape;
    twoEStr1110;
    twoEStr3112;
    ztv33btConvexConcaveCollisionAlgorithm;
    zti33btConvexConcaveCollisionAlgorithm;
    zts33btConvexConcaveCollisionAlgorithm;
    zti30btCollisionAlgorithmCreateFunc;
    zts30btCollisionAlgorithmCreateFunc;
    ztvn23btConvexConvexAlgorithm10CreateFuncE;
    ztin23btConvexConvexAlgorithm10CreateFuncE;
    ztsn23btConvexConvexAlgorithm10CreateFuncE;
    ztv24btPerturbedContactResult;
    zti24btPerturbedContactResult;
    zts24btPerturbedContactResult;
    twoEStr115;
    twoEStr4119;
    twoEStr5120;
    ztv23btConvexConvexAlgorithm;
    zti23btConvexConvexAlgorithm;
    zts23btConvexConvexAlgorithm;
    ztv31btConvexPlaneCollisionAlgorithm;
    zti31btConvexPlaneCollisionAlgorithm;
    zts31btConvexPlaneCollisionAlgorithm;
    ztvn31btConvexPlaneCollisionAlgorithm10CreateFuncE;
    ztin31btConvexPlaneCollisionAlgorithm10CreateFuncE;
    ztsn31btConvexPlaneCollisionAlgorithm10CreateFuncE;
    zti24btCollisionConfiguration;
    zts24btCollisionConfiguration;
    ztvn33btConvexConcaveCollisionAlgorithm10CreateFuncE;
    ztin33btConvexConcaveCollisionAlgorithm10CreateFuncE;
    ztsn33btConvexConcaveCollisionAlgorithm10CreateFuncE;
    ztvn33btConvexConcaveCollisionAlgorithm17SwappedCreateFuncE;
    ztin33btConvexConcaveCollisionAlgorithm17SwappedCreateFuncE;
    ztsn33btConvexConcaveCollisionAlgorithm17SwappedCreateFuncE;
    ztvn28btCompoundCollisionAlgorithm10CreateFuncE;
    ztin28btCompoundCollisionAlgorithm10CreateFuncE;
    ztsn28btCompoundCollisionAlgorithm10CreateFuncE;
    ztvn28btCompoundCollisionAlgorithm17SwappedCreateFuncE;
    ztin28btCompoundCollisionAlgorithm17SwappedCreateFuncE;
    ztsn28btCompoundCollisionAlgorithm17SwappedCreateFuncE;
    ztvn16btEmptyAlgorithm10CreateFuncE;
    ztin16btEmptyAlgorithm10CreateFuncE;
    ztsn16btEmptyAlgorithm10CreateFuncE;
    ztvn32btSphereSphereCollisionAlgorithm10CreateFuncE;
    ztin32btSphereSphereCollisionAlgorithm10CreateFuncE;
    ztsn32btSphereSphereCollisionAlgorithm10CreateFuncE;
    ztvn34btSphereTriangleCollisionAlgorithm10CreateFuncE;
    ztin34btSphereTriangleCollisionAlgorithm10CreateFuncE;
    ztsn34btSphereTriangleCollisionAlgorithm10CreateFuncE;
    ztvn26btBoxBoxCollisionAlgorithm10CreateFuncE;
    ztin26btBoxBoxCollisionAlgorithm10CreateFuncE;
    ztsn26btBoxBoxCollisionAlgorithm10CreateFuncE;
    twoEStr128;
    twoEStr1129;
    ztv31btDefaultCollisionConfiguration;
    zti31btDefaultCollisionConfiguration;
    zts31btDefaultCollisionConfiguration;
    ztv16btEmptyAlgorithm;
    zti16btEmptyAlgorithm;
    zts16btEmptyAlgorithm;
    ztv16btManifoldResult;
    twoEStr2149;
    twoEStr3150;
    twoEStr5152;
    twoEStr155;
    twoEStr1156;
    twoEStr2157;
    twoEStr3158;
    ztv25btSimulationIslandManager;
    zti25btSimulationIslandManager;
    zts25btSimulationIslandManager;
    ztv32btSphereSphereCollisionAlgorithm;
    zti32btSphereSphereCollisionAlgorithm;
    zts32btSphereSphereCollisionAlgorithm;
    ztv34btSphereTriangleCollisionAlgorithm;
    zti34btSphereTriangleCollisionAlgorithm;
    zts34btSphereTriangleCollisionAlgorithm;
    ztv22SphereTriangleDetector;
    zti22SphereTriangleDetector;
    zts22SphereTriangleDetector;
    twoEStr173;
    twoEStr2175;
    ztv10btBoxShape;
    zti10btBoxShape;
    zts10btBoxShape;
    twoEStr181;
    ztvzn22btBvhTriangleMeshShape14performRaycastEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback;
    ztizn22btBvhTriangleMeshShape14performRaycastEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback;
    ztszn22btBvhTriangleMeshShape14performRaycastEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback;
    ztvzn22btBvhTriangleMeshShape17performConvexcastEP18btTriangleCallbackRK9btVector3S4S4S4E21MyNodeOverlapCallback;
    ztizn22btBvhTriangleMeshShape17performConvexcastEP18btTriangleCallbackRK9btVector3S4S4S4E21MyNodeOverlapCallback;
    ztszn22btBvhTriangleMeshShape17performConvexcastEP18btTriangleCallbackRK9btVector3S4S4S4E21MyNodeOverlapCallback;
    ztvznk22btBvhTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback;
    ztiznk22btBvhTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback;
    ztsznk22btBvhTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback;
    twoEStr5186;
    twoEStr6187;
    twoEStr7188;
    twoEStr8189;
    ztv22btBvhTriangleMeshShape;
    zti22btBvhTriangleMeshShape;
    zts22btBvhTriangleMeshShape;
    zti19btTriangleMeshShape;
    zts19btTriangleMeshShape;
    zti14btConcaveShape;
    zts14btConcaveShape;
    twoEStr194;
    twoEStr4198;
    twoEStr6199;
    ztv14btCapsuleShape;
    zti14btCapsuleShape;
    zts14btCapsuleShape;
    twoEStr200;
    ztv14btConcaveShape;
    twoEStr219;
    twoEStr3222;
    ztv17btConvexHullShape;
    zti17btConvexHullShape;
    zts17btConvexHullShape;
    zti34btPolyhedralConvexAabbCachingShape;
    zts34btPolyhedralConvexAabbCachingShape;
    twoEStr5223;
    twoEStr6224;
    twoEStr6232;
    ztv13btConvexShape;
    twoEStr6249;
    twoEStr7250;
    ztvzn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4E20NodeTriangleCallback;
    ztizn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4E20NodeTriangleCallback;
    ztszn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4E20NodeTriangleCallback;
    ztvzn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4E29QuantizedNodeTriangleCallback;
    ztizn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4E29QuantizedNodeTriangleCallback;
    ztszn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4E29QuantizedNodeTriangleCallback;
    twoEStr10306;
    twoEStr18314;
    twoEStr19315;
    twoEStr20316;
    ztv14btOptimizedBvh;
    zti14btOptimizedBvh;
    zts14btOptimizedBvh;
    twoEStr7331;
    zgvzn34btPolyhedralConvexAabbCachingShape15recalcLocalAabbEvE11Directions;
    zzn34btPolyhedralConvexAabbCachingShape15recalcLocalAabbEvE11Directions;
    twoEStr342;
    ztv13btSphereShape;
    zti13btSphereShape;
    zts13btSphereShape;
    twoEStr349;
    twoEStr1350;
    twoEStr3352;
    twoEStr5354;
    twoEStr6355;
    twoEStr7356;
    twoEStr8357;
    twoEStr9358;
    ztv23btStridingMeshInterface;
    zti23btStridingMeshInterface;
    zts23btStridingMeshInterface;
    ztv31btInternalTriangleIndexCallback;
    ztv18btTriangleCallback;
    twoEStr367;
    twoEStr1368;
    ztv26btTriangleIndexVertexArray;
    zti26btTriangleIndexVertexArray;
    zts26btTriangleIndexVertexArray;
    twoEStr372;
    ztv21SupportVertexCallback;
    zti21SupportVertexCallback;
    zts21SupportVertexCallback;
    ztvznk19btTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4E16FilteredCallback;
    ztiznk19btTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4E16FilteredCallback;
    ztsznk19btTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4E16FilteredCallback;
    twoEStr3375;
    ztv19btTriangleMeshShape;
    ztv16btPointCollector;
    zti16btPointCollector;
    zts16btPointCollector;
    ztv27btContinuousConvexCollision;
    zti27btContinuousConvexCollision;
    zts27btContinuousConvexCollision;
    zti12btConvexCast;
    zts12btConvexCast;
    ztv12btConvexCast;
    ztv15btGjkConvexCast;
    zti15btGjkConvexCast;
    zts15btGjkConvexCast;
    zzn12gjkepa2Impl3GJK13projectoriginERK9btVector3S3S3PfRjE4imd3;
    zzn12gjkepa2Impl3EPA6expandEjPNS3GJK3sSVEPNS05sFaceEjRNS08sHorizonEE4i2m3;
    ztv30btGjkEpaPenetrationDepthSolver;
    zti30btGjkEpaPenetrationDepthSolver;
    zts30btGjkEpaPenetrationDepthSolver;
    gNumDeepPenetrationChecks;
    ztv17btGjkPairDetector;
    zti17btGjkPairDetector;
    zts17btGjkPairDetector;
    gNumGjkChecks;
    twoEStr425;
    twoEStr1426;
    twoEStr2427;
    twoEStr3428;
    gContactBreakingThreshold;
    twoEStr434;
    twoEStr3437;
    twoEStr4438;
    ztv28btTriangleConvexcastCallback;
    ztv22btSubsimplexConvexCast;
    zti22btSubsimplexConvexCast;
    zts22btSubsimplexConvexCast;
    twoEStr457;
    twoEStr1458;
    ztvn16btCollisionWorld27ClosestConvexResultCallbackE;
    ztin16btCollisionWorld27ClosestConvexResultCallbackE;
    ztsn16btCollisionWorld27ClosestConvexResultCallbackE;
    twoEStr36;
    twoEStr239;
    ztv21btConeTwistConstraint;
    zti21btConeTwistConstraint;
    zts21btConeTwistConstraint;
    twoEStr1340;
    twoEStr24;
    twoEStr442;
    twoEStr543;
    twoEStr846;
    twoEStr947;
    twoEStr1149;
    twoEStr29;
    ztv17btHingeConstraint;
    zti17btHingeConstraint;
    zts17btHingeConstraint;
    twoEStr130;
    twoEStr231;
    twoEStr332;
    twoEStr433;
    gNumSplitImpulseRecoveries;
    zti18btConstraintSolver;
    zts18btConstraintSolver;
    ztv35btSequentialImpulseConstraintSolver;
    zti35btSequentialImpulseConstraintSolver;
    zts35btSequentialImpulseConstraintSolver;
    zgvzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed;
    zzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed;
    twoEStr248;
    twoEStr34955;
    twoEStr450;
    twoEStr551;
    twoEStr652;
    twoEStr753;
    twoEStr854;
    twoEStr955;
    twoEStr1056;
    twoEStr1157;
    twoEStr76;
    zti23btDiscreteDynamicsWorld;
    zts23btDiscreteDynamicsWorld;
    zti15btDynamicsWorld;
    zts15btDynamicsWorld;
    ztin25btSimulationIslandManager14IslandCallbackE;
    ztsn25btSimulationIslandManager14IslandCallbackE;
    ztv34btClosestNotMeConvexResultCallback;
    zti34btClosestNotMeConvexResultCallback;
    zts34btClosestNotMeConvexResultCallback;
    ztvzn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoE27InplaceSolverIslandCallback;
    ztizn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoE27InplaceSolverIslandCallback;
    ztszn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoE27InplaceSolverIslandCallback;
    twoEStr87;
    twoEStr188;
    twoEStr289;
    twoEStr794;
    twoEStr895;
    gNumClampedCcdMotions;
    twoEStr996;
    twoEStr1097;
    twoEStr1198;
    twoEStr1299;
    twoEStr13100;
    twoEStr1461;
    twoEStr1562;
    twoEStr16101;
    ztv15btDynamicsWorld;
    ztv23btDiscreteDynamicsWorld;
    zl8uniqueId;
    ztv11btRigidBody;
    zti11btRigidBody;
    zts11btRigidBody;
    twoEStr4144;
    gDisableDeactivation;
    gNumAlignedAllocs;
    gNumAlignedFree;
    zn15CProfileManager12FrameCounterE;
    zn15CProfileManager4RootE;
    zl13gProfileClock2E0;
    zn15CProfileManager11CurrentNodeE;
    twoEStr729;
    zn4RwL12RwCatlistE2E0;
    zn4RwL12RwCatlistE2E1;
    zn4RwL12RwCatlistE2E2;
    llvm2EEh2ECatch2EAll2EValue;
    ztin4Rw10RwFacetE;
    ztsn4Rw10RwFacetE;
    ztin4Rw17RwSynchronizedE;
    ztsn4Rw17RwSynchronizedE;
    twoEStr4131;
    twoEStr15132;
    twoEStr26;
    zn4RwL13RwWhatBufE;
    zn4RwL16RwWhatRefcntE;
    twoEStr3133;
    twoEStr47;
    twoEStr5134;
    zzn4RwL13RwVfmtwhatEPcjiS0E7Fname;
    zzn4RwL13RwVfmtwhatEPcjiS0E6buffer;
    twoEStr7136;
    zzn4RwL13RwVfmtwhatEPcjiS0E8Catset;
    zzn4RwL13RwVfmtwhatEPcjiS0E4msgs;
    zzn4RwL13RwVfmtwhatEPcjiS0E5Cat;
    zzn4Rw10RwThrowEizE6errors;
    twoEStr8137;
    twoEStr9138;
    twoEStr10139;
    twoEStr11140;
    twoEStr12141;
    twoEStr138142;
    twoEStr14143;
    twoEStr159144;
    twoEStr16145;
    twoEStr17146;
    twoEStr18147;
    twoEStr19148;
    twoEStr20149;
    twoEStr21150;
    twoEStr22151;
    twoEStr23152;
    twoEStr24153;
    twoEStr25154;
    twoEStr2610;
    twoEStr27;
    twoEStr28155;
    twoEStr29156;
    twoEStr30;
    twoEStr31;
    twoEStr32157;
    twoEStr33;
    twoEStr134;
    twoEStr235;
    twoEStr336;
    twoEStr437;
    ztvn4Rw10RwFacetE;
    twoEStr538;
    zzn4Rw10RwFacet9CManageEPS0NS013CFacetTypeEPKcPFS1JS4EE12nStdFacets;
    zzn4Rw10RwFacet9CManageEPS0NS013CFacetTypeEPKcPFS1JS4EE10stdFacets;
    zzn4Rw10RwFacet9CManageEPS0NS013CFacetTypeEPKcPFS1JS4EE13stdFacetBuf;
    zzn4Rw10RwFacet9CManageEPS0NS013CFacetTypeEPKcPFS1JS4EE17stdFacetBufsize;
    zzn4Rw10RwFacetD4EvE9destroyed;
    zn4Rw9RwCatsE;
    twoEStr785;
    zzn4Rw11RwLocale9CManageEPS0PKcE6global;
    zzn4Rw11RwLocale9CManageEPS0PKcE5ginit;
    zzn4Rw11RwLocale9CManageEPS0PKcE9nLocales;
    zzn4Rw11RwLocale9CManageEPS0PKcE7locales;
    zzn4Rw11RwLocale9CManageEPS0PKcE10localeBuf;
    zzn4Rw11RwLocale9CManageEPS0PKcE14localeBufsize;
    zzn4Rw11RwLocale9CManageEPS0PKcE7classic;
    zzn4Rw11RwLocale9CManageEPS0PKcE12classicBody;
    zn4RwL22RwClassicOnceInitE2E02EB;
    zn4RwL12RwClassicE;
    twoEStr292167;
    twoEStr10100175;
    twoEStr12102177;
    zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE4init2EB;
    zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE8catalogs;
    zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE11catalogBuf;
    zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE15catalogBufsize;
    zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE10nCatalogs;
    zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE11largestCat;
    twoEStr115180;
    twoEStr1116181;
    twoEStr2131;
    twoEStr4133;
    zzn4Rw16RwLocaleNameEiPKcRNS14RwPodArrayIcLj256EEEE11localeRoot;
    znss11CNullRefE;
    ztvst8messagesIcE;
    ztist8messagesIcE;
    ztsst8messagesIcE;
    ztist13messagesBase;
    ztsst13messagesBase;
    twoEStr2360;
    twoEStr3361;
    twoEStr4362;
    ztvst9typeInfo;
    ztist9typeInfo;
    ztsst9typeInfo;
    sMaxMemory;
    sCurrentMemory;
    blockNull;
    twoEStr643;
    twoEStr1648;
    twoEStr4651;
    twoEStr5652;
    myCtype;
    zl8nextRand;
    twoEStr7654;
    twoEStr9655;
    zl8padLine;
    zl10strtokPos;
    zti14CFileInterface;
    zts14CFileInterface;
    ztv11CFileSystem;
    zti11CFileSystem;
    zts11CFileSystem;
    zl13sFileStdout;
    ztv7CFileLS;
    zti7CFileLS;
    zts7CFileLS;
    ztv10CFileCloud;
    zti10CFileCloud;
    zts10CFileCloud;
    zl10sASockets;
    ztv11CFileStdout;
    zti11CFileStdout;
    zts11CFileStdout;
    twoEStr31677;
    twoEStr32678;
    twoEStr33679;
    twoEStr34680;
    twoEStr35681;
    twoEStr37683;
    twoEStr38684;
    zn12mandreelB64L9b64CharsE;
    zn12mandreelB64L11b64IndexesE;
    zl25sMandreelInternalWidth;
    zl26sMandreelInternalHeight;
    gMsgcallback;
    zl24gPFirstTextureAsyncInfo;
    zl17gApPackFileNames;
    zgvz21MandreelGetTickCountE7sFirst;
    zz21MandreelGetTickCountE7sFirst;
    zz29MandreelInternalPreupdateE8sBfirst2EB;
    twoEStr779;
    twoEStr3782;
    twoEStr4783;
    twoEStr5784;
    twoEStr6785;
    zz24MandreelInternalInitE54s723478567MandreelMandreelInternalSetResolution;
    zz24MandreelInternalInitE56s723478567MandreelIMandreelTextureAsyncIsCompressed;
    zz24MandreelInternalInitE57s723478567MandreelIMandreelTextureAsyncGetPackOffset;
    zz24MandreelInternalInitE29s723478567MandreelResize;
    zz24MandreelInternalInitE48s723478567MandreelImandreelRestoreGlcontext;
    zz24MandreelInternalInitE46s723478567MandreelImandreelViewportResize;
    ztvn10Cxxabiv120SiClassTypeInfoE;
    ztin10Cxxabiv120SiClassTypeInfoE;
    ztsn10Cxxabiv120SiClassTypeInfoE;
    ztin10Cxxabiv117ClassTypeInfoE;
    ztsn10Cxxabiv117ClassTypeInfoE;
    ztvn10Cxxabiv117ClassTypeInfoE;
    ztvn10Cxxabiv121VmiClassTypeInfoE;
    ztin10Cxxabiv121VmiClassTypeInfoE;
    ztsn10Cxxabiv121VmiClassTypeInfoE;
    zl11gAChannels;
    zl7gBInit2EB;
    twoEStr221;
    twoEStr1222;
    zl21gPFirstSoundDuration;
    twoEStr3224;
    twoEStr4225;
    zl15gIFreeChannels;
    zl15gAFreeChannels;
    zl6gBLog;
    twoEStr12233;
    twoEStr22243;
    twoEStr24245;
    twoEStr26247;
    twoEStr27248;
    twoEStr28249;
    twoEStr29250;
    twoEStr30251;
    twoEStr31252;
    twoEStr32253;
    twoEStr33254;
    twoEStr34255;
    twoEStr35256;
    zzl32MandreelInitTcpSocketLibrayvE47s723478567MandreelMandreelFlashTcpOnError;
    zl13sFifoErrors;
    zn5myGlL9mContextE;
    llvm2EGlobalCtors;
    llvm2EGlobalDtors;
    llvm2EUsed;
  }
}

function cosf(sp: number): void {
  let value = heapClassInst.heapFloat[sp >> numDefine2];
  commonVariable.fg0 = Math.cos(value);
}

function dump(x: string | number): void {}

function fillPtrFromString(ptr: number, v: string): void {
  ptr = ptr;
  for (let j = 0; j < v.length; j++) {
    let data: number = v.charCodeAt(j);

    heapClassInst.heapU8[ptr] = data;
    ptr += 1;
  }
  heapClassInst.heapU8[ptr] = 0;
}

function fmodf(sp: number): void {
  sp = sp;
  let value: number = heapClassInst.heapFloat[sp >> numDefine2];
  sp += numDefine4;
  let value2: number = heapClassInst.heapFloat[sp >> numDefine2];
}

function free(sp: number): void {
  sp = sp;
  let ptr = heapClassInst.heapU32[sp >> numDefine2];
  sp -= numDefine8;

  heapClassInst.heap32[sp >> numDefine2] = tlsfPtr.tlsfPtr;
  heapClassInst.heap32[(sp + numDefine4) >> numDefine2] = ptr;
  tlsfFree(sp);
}

function getTimeOfDay(sp: number): void {
  let ptr: number = heapClassInst.heap32[sp >> numDefine2];
  let timeMs: number = dateNow();
  heapClassInst.heap32[ptr >> numDefine2] = timeMs / numDefine1000;
  heapClassInst.heap32[(ptr >> numDefine2) + 1] = (timeMs % numDefine1000) * numDefine1000;
  commonVariable.rg0 = 0;
}

function dateNow(): number {
  commonVariable.mandreelCurrentTime += numDefine16;
  return commonVariable.mandreelCurrentTime;
}

function updateMandreelStats(time: number): void {
  let pause = time - commonVariable.mandreelSampleTimeStart;
  commonVariable.mandreelSampleTimeStart = time;
  commonVariable.mandreelPauseTimes.push(pause);
}

function jsMandreelFlashTcpUpdate(sp: number): void {}

function mandreelInternalCreateWindow(sp: number): void {}

function iMandreelRegisterExternalCallback(sp: number): void {}

function z30MandreelFopenEnableCheckfatb(sp: number): void {}

function mandreelTextureAsyncSetData(sp: number): void {
  sp = sp;
  let textureId = heapClassInst.heap32[sp >> numDefine2];
  sp += numDefine4;

  let tex: ArrayUniformLocations | null = arrayIdsOgl[textureId];

  if (commonVariable.mandreelAppPlatform !== 'canvas') {
    tex = null;
  }
}

function blockMergeNext(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1 + 1];
  r2 = (r2 + numDefineNeg4) | 0;
  r2 = r2 & numDefineNeg4;
  r3 = (r0 + numDefine8) | 0;
  r4 = (r2 + numDefine4) | 0;
  r4 = (r3 + r4) | 0;
  r4 = r4 >> numDefine2;
  r5 = heapClassInst.heap32[r4];
  r6 = r5 & 1;
  if (!(r6 === 0)) {
    r6 = heapClassInst.heap32[fp];
    r7 = (r3 + r2) | 0;
    r8 = r5 & numDefineNeg4;
    if (uint(r8) > uint(numDefine255)) {
      r5 = r8 >>> 1;
      r5 = r8 | r5;
      r9 = r5 >>> numDefine2;
      r5 = r5 | r9;
      r9 = r5 >>> numDefine4;
      r5 = r5 | r9;
      r9 = r5 >>> numDefine8;
      r5 = r5 | r9;
      r9 = r5 >>> numDefine16;
      r5 = r5 | r9;
      r9 = r5 ^ -1;
      r10 = numDefine55765;
      r9 = r9 >>> 1;
      r5 = r10 & ~r5;
      r9 = r9 & numDefine55765;
      r5 = (r5 + r9) | 0;
      r9 = r5 >>> numDefine2;
      r5 = r5 & numDefine93459;
      r9 = r9 & numDefine93459;
      r5 = (r5 + r9) | 0;
      r9 = r5 >>> numDefine4;
      r5 = r5 & numDefine45135;
      r9 = r9 & numDefine45135;
      r5 = (r5 + r9) | 0;
      r9 = r5 >>> numDefine8;
      r5 = r5 & numDefine11935;
      r9 = r9 & numDefine11935;
      r5 = (r5 + r9) | 0;
      r9 = r5 & numDefine65535;
      r5 = r5 >>> numDefine16;
      r10 = numDefine26;
      r5 = (r9 + r5) | 0;
      r9 = (r10 - r5) | 0;
      r8 = r8 >>> r9;
      r9 = numDefine24;
      r8 = r8 ^ numDefine32;
      r5 = (r9 - r5) | 0;
    } else {
      r8 = r5 >>> numDefine3;
      r5 = 0;
    }
    r2 = (r2 + r3) | 0;
    r2 = r2 >> numDefine2;
    r9 = r5 << numDefine7;
    r10 = heapClassInst.heap32[r2 + numDefine2];
    r2 = heapClassInst.heap32[r2 + numDefine3];
    r9 = (r6 + r9) | 0;
    r11 = r8 << numDefine2;
    r9 = (r9 + r11) | 0;
    r11 = r10 >> numDefine2;
    r12 = r2 >> numDefine2;
    heapClassInst.heap32[r11 + numDefine3] = r2;
    r2 = r9 >> numDefine2;
    heapClassInst.heap32[r12 + numDefine2] = r10;
    r2 = heapClassInst.heap32[r2 + numDefine24];
    if (!(r2 !== r7)) {
      r2 = (r9 + numDefine96) | 0;
      r2 = r2 >> numDefine2;
      r7 = blockNull;
      heapClassInst.heap32[r2] = r10;
      if (!(r10 !== r7)) {
        r2 = r5 << numDefine2;
        r2 = (r6 + r2) | 0;
        r2 = r2 >> numDefine2;
        r7 = 1;
        r8 = r7 << r8;
        r9 = heapClassInst.heap32[r2 + 1];
        r8 = r9 & ~r8;
        heapClassInst.heap32[r2 + 1] = r8;
        if (!(r8 !== 0)) {
          r2 = r6 >> numDefine2;
          r5 = r7 << r5;
          r6 = heapClassInst.heap32[r2];
          r5 = r6 & ~r5;
          heapClassInst.heap32[r2] = r5;
        }
      }
    }
    r2 = heapClassInst.heap32[r4];
    r4 = heapClassInst.heap32[r1 + 1];
    r2 = r2 & numDefineNeg4;
    r2 = (r2 + r4) | 0;
    r4 = r2 & numDefineNeg4;
    r3 = (r3 + r4) | 0;
    r2 = (r2 + numDefine4) | 0;
    r3 = r3 >> numDefine2;
    heapClassInst.heap32[r1 + 1] = r2;
    heapClassInst.heap32[r3] = r0;
  }
  commonVariable.rg0 = r0;
  return;
}

function mandreelAddValidFopenfile(param: number): void {}

function mandreelFread(sp: number): void {}

function mandreelFclose(sp: number): void {
  sp = sp;
  let fileId = heapClassInst.heap32[sp >> numDefine2];
  sp += numDefine4;

  fileIds[fileId] = null;
  commonVariable.rg0 = 0;
}

function mandreelFeof(sp: number): void {
  sp = sp;
  let fileId = heapClassInst.heap32[sp >> numDefine2];
  sp += numDefine4;

  let offset = fileIds[fileId]!.offset;
  let total = fileIds[fileId]!.count;

  if (offset >= total) {
    commonVariable.rg0 = 1;
  } else {
    commonVariable.rg0 = 0;
  }
}

function mandreelFtell(sp: number): void {
  sp = sp;
  let fileId = heapClassInst.heap32[sp >> numDefine2];
  sp += numDefine4;

  let value = fileIds[fileId]!.offset;

  commonVariable.rg0 = value;
}

function mandreelFseek(sp: number): void {
  sp = sp;
  let fileId = heapClassInst.heap32[sp >> numDefine2];
  sp += numDefine4;
  let pos = heapClassInst.heap32[sp >> numDefine2];
  sp += numDefine4;
  let type = heapClassInst.heap32[sp >> numDefine2];
  sp += numDefine4;

  if (type === numDefine2) {
    fileIds[fileId]!.offset = fileIds[fileId]!.count + pos;
  } else if (type === 1) {
    fileIds[fileId]!.offset = fileIds[fileId]!.offset + pos;
  } else if (type === 0) {
    fileIds[fileId]!.offset = pos;
  }

  commonVariable.rg0 = 0;
}

function mandreelUngetc(sp: number): number {
  sp = sp;
  let myChar = heapClassInst.heap32[sp >> numDefine2];
  sp += numDefine4;
  let fileId = heapClassInst.heap32[sp >> numDefine2];
  sp += numDefine4;

  let offset = fileIds[fileId]!.offset - 1;

  let byteArray = fileIds[fileId]!.byteArray;

  assert(byteArray[offset] === myChar);

  fileIds[fileId]!.offset = offset;

  return myChar;
}

function realloc(sp: number): void {
  sp = sp;
  let ptr = heapClassInst.heapU32[sp >> numDefine2];
  let size = heapClassInst.heapU32[(sp + numDefine4) >> numDefine2];

  sp -= numDefine12;

  heapClassInst.heap32[sp >> numDefine2] = tlsfPtr.tlsfPtr;
  heapClassInst.heap32[(sp + numDefine4) >> numDefine2] = ptr;
  heapClassInst.heap32[(sp + numDefine8) >> numDefine2] = size;
  tlsfRealloc(sp);
}

function tlsfRealloc(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let label = 0;

  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heap32[fp];
  r2 = heapClassInst.heap32[fp + numDefine2];
  if (!(r0 === 0)) {
    if (!(r2 !== 0)) {
      heapClassInst.heap32[g0] = r1;
      heapClassInst.heap32[g0 + 1] = r0;
      tlsfFree(i7);
      r0 = 0;
      commonVariable.rg0 = r0;
      return;
    }
  }
  if (r0 !== 0) {
    r3 = r0 >> numDefine2;
    r4 = heapClassInst.heap32[r3 + -1];
    r5 = r4 & numDefineNeg4;
    r6 = (r0 + r5) | 0;
    r6 = r6 >> numDefine2;
    r6 = heapClassInst.heap32[r6];
    r7 = r6 & numDefineNeg4;
    r7 = (r5 + r7) | 0;
    r8 = (r2 + -1) | 0;
    r9 = (r0 + numDefineNeg8) | 0;
    r7 = (r7 + numDefine4) | 0;
    if (uint(r8) < uint(numDefine41823)) {
      r10 = (r2 + numDefine7) | 0;
      r10 = r10 & numDefineNeg8;
      r11 = numDefine12;
      r10 = uint(r10) < uint(r11) ? r11 : r10;
    } else {
      r10 = 0;
    }
    repeat11: do {
      if (uint(r10) > uint(r5)) {
        r4 = r6 & 1;
        if (!(r4 === 0)) {
          if (uint(r10) <= uint(r7)) {
            heapClassInst.heap32[g0] = r1;
            heapClassInst.heap32[g0 + 1] = r9;
            blockMergeNext(i7);
            r4 = heapClassInst.heap32[r3 + -1];
            r4 = r4 & numDefineNeg4;
            r4 = (r0 + r4) | 0;
            r4 = r4 >> numDefine2;
            r9 = heapClassInst.heap32[r4];
            r9 = r9 & numDefineNeg3;
            heapClassInst.heap32[r4] = r9;
            r4 = heapClassInst.heap32[r3 + -1];
            r4 = r4 & numDefineNeg2;
            heapClassInst.heap32[r3 + -1] = r4;
            break repeat11;
          }
        }
        if (uint(r8) < uint(numDefine41823)) {
          r3 = (r2 + numDefine7) | 0;
          r3 = r3 & numDefineNeg8;
          r4 = numDefine12;
          r3 = uint(r3) < uint(r4) ? r4 : r3;
        } else {
          r3 = 0;
        }
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = r3;
        blockLocateFree(i7);
        r4 = commonVariable.rg0;
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = r4;
        heapClassInst.heap32[g0 + numDefine2] = r3;
        r3 = sCurrentMemory;
        blockPrepareUsed(i7);
        r9 = commonVariable.rg0;
        r4 = r4 >> numDefine2;
        r3 = r3 >> numDefine2;
        r4 = heapClassInst.heap32[r4 + 1];
        r10 = heapClassInst.heap32[r3];
        r4 = r4 & numDefineNeg4;
        r4 = (r10 + r4) | 0;
        r10 = sMaxMemory;
        r10 = r10 >> numDefine2;
        heapClassInst.heap32[r3] = r4;
        r3 = heapClassInst.heap32[r10];
        if (!(uint(r4) <= uint(r3))) {
          heapClassInst.heap32[r10] = r4;
        }
        if (r9 === 0) {
          commonVariable.rg0 = r9;
          return;
        } else {
          r3 = uint(r5) >= uint(r2) ? r2 : r5;
          heapClassInst.heap32[g0] = r9;
          heapClassInst.heap32[g0 + 1] = r0;
          heapClassInst.heap32[g0 + numDefine2] = r3;
          memcpy(i7);
          heapClassInst.heap32[g0] = r1;
          heapClassInst.heap32[g0 + 1] = r0;
          tlsfFree(i7);
          commonVariable.rg0 = r9;
          return;
        }
      }
    } while (false);
    r9 = sCurrentMemory;
    r9 = r9 >> numDefine2;
    r2 = heapClassInst.heap32[r9];
    r2 = (r2 - r5) | 0;
    r5 = r4 & numDefineNeg4;
    heapClassInst.heap32[r9] = r2;
    r6 = (r10 + numDefine16) | 0;
    if (uint(r5) >= uint(r6)) {
      r4 = (r0 + r10) | 0;
      r6 = r4 >> numDefine2;
      r7 = numDefineNeg4;
      r8 = heapClassInst.heap32[r6];
      r7 = (r7 - r10) | 0;
      r8 = r8 & numDefine3;
      r5 = (r7 + r5) | 0;
      r5 = r8 | r5;
      heapClassInst.heap32[r6] = r5;
      r5 = heapClassInst.heap32[r3 + -1];
      r5 = r5 & numDefine3;
      r5 = r5 | r10;
      heapClassInst.heap32[r3 + -1] = r5;
      r5 = heapClassInst.heap32[r6];
      r5 = (r5 + numDefineNeg4) | 0;
      r5 = r5 & numDefineNeg4;
      r5 = (r10 + r5) | 0;
      r5 = (r5 + r0) | 0;
      r4 = (r4 + numDefineNeg4) | 0;
      r5 = r5 >> numDefine2;
      heapClassInst.heap32[r5 + 1] = r4;
      r7 = heapClassInst.heap32[r5 + numDefine2];
      r7 = r7 | numDefine2;
      heapClassInst.heap32[r5 + numDefine2] = r7;
      r5 = heapClassInst.heap32[r6];
      r5 = r5 | 1;
      r5 = r5 & numDefineNeg3;
      heapClassInst.heap32[r6] = r5;
      heapClassInst.heap32[g0] = r1;
      heapClassInst.heap32[g0 + 1] = r4;
      blockMergeNext(i7);
      r4 = commonVariable.rg0;
      r5 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r5 + 1];
      r6 = r5 & numDefineNeg4;
      if (uint(r6) > uint(numDefine255)) {
        r5 = r6 >>> 1;
        r5 = r6 | r5;
        r7 = r5 >>> numDefine2;
        r5 = r5 | r7;
        r7 = r5 >>> numDefine4;
        r5 = r5 | r7;
        r7 = r5 >>> numDefine8;
        r5 = r5 | r7;
        r7 = r5 >>> numDefine16;
        r5 = r5 | r7;
        r7 = r5 ^ -1;
        r8 = numDefine55765;
        r7 = r7 >>> 1;
        r5 = r8 & ~r5;
        r7 = r7 & numDefine55765;
        r5 = (r5 + r7) | 0;
        r7 = r5 >>> numDefine2;
        r5 = r5 & numDefine93459;
        r7 = r7 & numDefine93459;
        r5 = (r5 + r7) | 0;
        r7 = r5 >>> numDefine4;
        r5 = r5 & numDefine45135;
        r7 = r7 & numDefine45135;
        r5 = (r5 + r7) | 0;
        r7 = r5 >>> numDefine8;
        r5 = r5 & numDefine11935;
        r7 = r7 & numDefine11935;
        r5 = (r5 + r7) | 0;
        r7 = r5 & numDefine65535;
        r5 = r5 >>> numDefine16;
        r8 = numDefine26;
        r5 = (r7 + r5) | 0;
        r7 = (r8 - r5) | 0;
        r6 = r6 >>> r7;
        r7 = numDefine24;
        r6 = r6 ^ numDefine32;
        r5 = (r7 - r5) | 0;
      } else {
        r6 = r5 >>> numDefine3;
        r5 = 0;
      }
      r7 = r5 << numDefine7;
      r7 = (r1 + r7) | 0;
      r8 = r6 << numDefine2;
      r7 = (r7 + r8) | 0;
      r7 = r7 >> numDefine2;
      r8 = heapClassInst.heap32[r7 + numDefine24];
      r10 = r4 >> numDefine2;
      r11 = blockNull;
      heapClassInst.heap32[r10 + numDefine2] = r8;
      r8 = r8 >> numDefine2;
      heapClassInst.heap32[r10 + numDefine3] = r11;
      heapClassInst.heap32[r8 + numDefine3] = r4;
      r8 = 1;
      r10 = r1 >> numDefine2;
      heapClassInst.heap32[r7 + numDefine24] = r4;
      r4 = r5 << numDefine2;
      r5 = r8 << r5;
      r7 = heapClassInst.heap32[r10];
      r4 = (r1 + r4) | 0;
      r1 = r7 | r5;
      r4 = r4 >> numDefine2;
      heapClassInst.heap32[r10] = r1;
      r1 = r8 << r6;
      r5 = heapClassInst.heap32[r4 + 1];
      r1 = r5 | r1;
      heapClassInst.heap32[r4 + 1] = r1;
      r4 = heapClassInst.heap32[r3 + -1];
    }
    r1 = r4 & numDefineNeg4;
    r1 = (r2 + r1) | 0;
    r2 = sMaxMemory;
    r2 = r2 >> numDefine2;
    heapClassInst.heap32[r9] = r1;
    r9 = heapClassInst.heap32[r2];
    if (!(uint(r1) <= uint(r9))) {
      heapClassInst.heap32[r2] = r1;
    }
    commonVariable.rg0 = r0;
    return;
  } else {
    r0 = (r2 + -1) | 0;
    if (uint(r0) < uint(numDefine41823)) {
      r0 = (r2 + numDefine7) | 0;
      r0 = r0 & numDefineNeg8;
      r2 = numDefine12;
      r0 = uint(r0) < uint(r2) ? r2 : r0;
    } else {
      r0 = 0;
    }
    heapClassInst.heap32[g0] = r1;
    heapClassInst.heap32[g0 + 1] = r0;
    blockLocateFree(i7);
    r2 = commonVariable.rg0;
    heapClassInst.heap32[g0] = r1;
    heapClassInst.heap32[g0 + 1] = r2;
    heapClassInst.heap32[g0 + numDefine2] = r0;
    r0 = sCurrentMemory;
    blockPrepareUsed(i7);
    r1 = commonVariable.rg0;
    r2 = r2 >> numDefine2;
    r0 = r0 >> numDefine2;
    r2 = heapClassInst.heap32[r2 + 1];
    r3 = heapClassInst.heap32[r0];
    r2 = r2 & numDefineNeg4;
    r2 = (r3 + r2) | 0;
    r3 = sMaxMemory;
    r3 = r3 >> numDefine2;
    heapClassInst.heap32[r0] = r2;
    r0 = heapClassInst.heap32[r3];
    if (!(uint(r2) <= uint(r0))) {
      heapClassInst.heap32[r3] = r2;
    }
    commonVariable.rg0 = r1;
    return;
  }
}

function mandreelWritels(sp: number): void {}

function mandreelOpenls(sp: number): void {
  sp = sp;
  let ptrName = heapClassInst.heap32[sp >> numDefine2];
  sp += numDefine4;

  let key = getStringFromPtr(ptrName);

  let myLocalStorage = mandreelGetlocalstorage();

  let value: string | null = myLocalStorage!.getItem(key);

  if (value === null) {
    commonVariable.rg0 = -1;
    return;
  }

  let length = myLocalStorage!.getItem(key + 'Size');

  if (length === null) {
    commonVariable.rg0 = -1;
    return;
  }

  dump('mandreelOpenls ' + key + ' return ' + length);

  commonVariable.rg0 = Number(length);
}

function mandreelReadcloud(sp: number): void {}

function mandreelFopen(sp: number): void {
  sp = sp;
  let ptrName = heapClassInst.heap32[sp >> numDefine2];
  sp += numDefine4;
  let ptrFlags = heapClassInst.heap32[sp >> numDefine2];
  sp += numDefine4;

  let name = getStringFromPtr(ptrName);
  let flags = getStringFromPtr(ptrFlags);

  name = name.toLowerCase();

  let buffer: number | null = mandreelCacheFiles[name];

  if (buffer == null) {
    commonVariable.rg0 = 0;
    return;
  }

  fileIds[currentFileId] = new CreateFileId(new ArrayBuffer(buffer));

  let oldId: number = currentFileId;
  currentFileId += 1;
  commonVariable.rg0 = oldId;
}

function mandreelReadls(sp: number): void {}

function mandreelOpencloud(param: number): void {}

function mandreelWritecloud(param: number): void {}

function llvmWriteDouble(addr: number, src: number): void {
  heapClassInst.heapDouble[llvmDoubleAddr >> numDefine3] = src;

  let val0 = heapClassInst.heap32[llvmDoubleAddr >> numDefine2];
  let val1 = heapClassInst.heap32[(llvmDoubleAddr + numDefine4) >> numDefine2];

  heapClassInst.heap32[addr >> numDefine2] = val0;
  heapClassInst.heap32[(addr + numDefine4) >> numDefine2] = val1;
}

function uint(value: number): number {
  if (value >= 0) {
    return value;
  }
  return numDefine67296 + value;
}

function tlsfCreate(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let label = 0;

  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r0 = (r0 + numDefineNeg3048) | 0;
  r1 = r0 & numDefineNeg8;
  r2 = (r1 + numDefineNeg12) | 0;
  if (uint(r2) < uint(numDefine41813)) {
    r2 = heapClassInst.heap32[fp];
    r3 = blockNull;
    r4 = r3 >> numDefine2;
    heapClassInst.heap32[r4 + numDefine2] = r3;
    r5 = -1;
    r6 = r2 >> numDefine2;
    heapClassInst.heap32[r4 + numDefine3] = r3;
    heapClassInst.heap32[r6] = 0;
    repeat3: while (true) {
      r4 = r5 << numDefine2;
      r7 = r5 << numDefine7;
      r4 = (r2 - r4) | 0;
      r7 = (r2 - r7) | 0;
      r4 = r4 >> numDefine2;
      r7 = r7 >> numDefine2;
      heapClassInst.heap32[r4] = 0;
      heapClassInst.heap32[r7 + numDefineNeg8] = r3;
      heapClassInst.heap32[r7 + numDefineNeg7] = r3;
      heapClassInst.heap32[r7 + numDefineNeg6] = r3;
      heapClassInst.heap32[r7 + numDefineNeg5] = r3;
      heapClassInst.heap32[r7 + numDefineNeg4] = r3;
      heapClassInst.heap32[r7 + numDefineNeg3] = r3;
      heapClassInst.heap32[r7 + numDefineNeg2] = r3;
      heapClassInst.heap32[r7 + -1] = r3;
      heapClassInst.heap32[r7] = r3;
      heapClassInst.heap32[r7 + 1] = r3;
      heapClassInst.heap32[r7 + numDefine2] = r3;
      heapClassInst.heap32[r7 + numDefine3] = r3;
      heapClassInst.heap32[r7 + numDefine4] = r3;
      heapClassInst.heap32[r7 + numDefine5] = r3;
      heapClassInst.heap32[r7 + numDefine6] = r3;
      heapClassInst.heap32[r7 + numDefine7] = r3;
      heapClassInst.heap32[r7 + numDefine8] = r3;
      heapClassInst.heap32[r7 + numDefine9] = r3;
      heapClassInst.heap32[r7 + numDefine10] = r3;
      heapClassInst.heap32[r7 + numDefine11] = r3;
      heapClassInst.heap32[r7 + numDefine12] = r3;
      heapClassInst.heap32[r7 + numDefine13] = r3;
      heapClassInst.heap32[r7 + numDefine14] = r3;
      heapClassInst.heap32[r7 + numDefine15] = r3;
      heapClassInst.heap32[r7 + numDefine16] = r3;
      heapClassInst.heap32[r7 + numDefine17] = r3;
      heapClassInst.heap32[r7 + numDefine18] = r3;
      heapClassInst.heap32[r7 + numDefine19] = r3;
      heapClassInst.heap32[r7 + numDefine20] = r3;
      heapClassInst.heap32[r7 + numDefine21] = r3;
      r5 = (r5 + -1) | 0;
      heapClassInst.heap32[r7 + numDefine22] = r3;
      heapClassInst.heap32[r7 + numDefine23] = r3;
      if (!(r5 !== numDefineNeg24)) {
        break repeat3;
      }
    }
    r4 = r0 | 1;
    r5 = (r2 + numDefine3036) | 0;
    r4 = r4 & numDefineNeg7;
    heapClassInst.heap32[r6 + numDefine760] = r4;
    if (uint(r1) > uint(numDefine255)) {
      r0 = r1 >>> 1;
      r0 = r1 | r0;
      r4 = r0 >>> numDefine2;
      r0 = r0 | r4;
      r4 = r0 >>> numDefine4;
      r0 = r0 | r4;
      r4 = r0 >>> numDefine8;
      r0 = r0 | r4;
      r4 = r0 >>> numDefine16;
      r0 = r0 | r4;
      r4 = r0 ^ -1;
      r7 = numDefine55765;
      r4 = r4 >>> 1;
      r0 = r7 & ~r0;
      r4 = r4 & numDefine55765;
      r0 = (r0 + r4) | 0;
      r4 = r0 >>> numDefine2;
      r0 = r0 & numDefine93459;
      r4 = r4 & numDefine93459;
      r0 = (r0 + r4) | 0;
      r4 = r0 >>> numDefine4;
      r0 = r0 & numDefine45135;
      r4 = r4 & numDefine45135;
      r0 = (r0 + r4) | 0;
      r4 = r0 >>> numDefine8;
      r0 = r0 & numDefine11935;
      r4 = r4 & numDefine11935;
      r0 = (r0 + r4) | 0;
      r4 = r0 & numDefine65535;
      r0 = r0 >>> numDefine16;
      r7 = numDefine26;
      r0 = (r4 + r0) | 0;
      r4 = (r7 - r0) | 0;
      r1 = r1 >>> r4;
      r4 = numDefine24;
      r1 = r1 ^ numDefine32;
      r0 = (r4 - r0) | 0;
    } else {
      r1 = r0 >>> numDefine3;
      r0 = 0;
    }
    r4 = r0 << numDefine7;
    r4 = (r2 + r4) | 0;
    r7 = r1 << numDefine2;
    r4 = (r4 + r7) | 0;
    r4 = r4 >> numDefine2;
    r7 = heapClassInst.heap32[r4 + numDefine24];
    heapClassInst.heap32[r6 + numDefine761] = r7;
    r7 = r7 >> numDefine2;
    heapClassInst.heap32[r6 + numDefine762] = r3;
    heapClassInst.heap32[r7 + numDefine3] = r5;
    r3 = 1;
    heapClassInst.heap32[r4 + numDefine24] = r5;
    r4 = r0 << numDefine2;
    r0 = r3 << r0;
    r7 = heapClassInst.heap32[r6];
    r4 = (r2 + r4) | 0;
    r0 = r7 | r0;
    r4 = r4 >> numDefine2;
    heapClassInst.heap32[r6] = r0;
    r0 = r3 << r1;
    r1 = heapClassInst.heap32[r4 + 1];
    r0 = r1 | r0;
    heapClassInst.heap32[r4 + 1] = r0;
    r0 = heapClassInst.heap32[r6 + numDefine760];
    r0 = (r0 + numDefine3040) | 0;
    r0 = r0 & numDefineNeg4;
    r0 = (r2 + r0) | 0;
    r0 = r0 >> numDefine2;
    heapClassInst.heap32[r0] = r5;
    heapClassInst.heap32[r0 + 1] = numDefine2;
    commonVariable.rg0 = r2;
    return;
  } else {
    r0 = twoEStr643;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = numDefine3060;
    heapClassInst.heap32[g0 + numDefine2] = numDefine44872;
    printf(i7);
    r0 = 0;
    commonVariable.rg0 = r0;
    return;
  }
}

function printf(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16408;
  let g0 = i7 >> numDefine2;
  r0 = (sp + numDefine4) | 0;
  heapClassInst.heap32[fp + numDefineNeg4097] = r0;
  r1 = sp + numDefineNeg16384;
  r2 = heapClassInst.heap32[fp];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = numDefine16384;
  heapClassInst.heap32[g0 + numDefine2] = r2;
  heapClassInst.heap32[g0 + numDefine3] = r0;
  r0 = gMsgcallback;
  r0 = r0 >> numDefine2;
  vsnprintf(i7);
  r0 = heapClassInst.heap32[r0];
  if (!(r0 === 0)) {
    heapClassInst.heap32[g0] = r1;
    sandboxOutputDebugString(i7);
  }
  return;
}

function sandboxOutputDebugString(sp: number): void {
  puts(sp);
}

function puts(sp: number, type: string = ''): void {
  let addr: number = heapClassInst.heapU32[sp >> numDefine2];

  let name = getStringFromPtr(addr);

  name += '\n';

  dump(name);
}

function getStringFromPtr(ptr: number): string {
  let ret = '';

  if (ptr === 0) {
    return ret;
  }
  let i = 0;
  while (true) {
    if (heapClassInst.heapU8[ptr + i] === 0) {
      break;
    }

    let t = String.fromCharCode(heapClassInst.heapU8[ptr + i]);
    ret += t;
    i += 1;
  }

  return ret;
}

function strtol(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap8[r0];
  r2 = r1 << numDefine2;
  r3 = myCtype;
  r2 = (r2 + r3) | 0;
  r4 = heapClassInst.heap32[fp + 1];
  r2 = heapClassInst.heapU8[r2 + numDefine4];
  r2 = r2 & numDefine8;
  if (r2 === 0) {
    r2 = r0;
  } else {
    r2 = r0;
    repeat4: while (true) {
      r1 = heapClassInst.heap8[r2 + 1];
      r5 = r1 << numDefine2;
      r5 = (r5 + r3) | 0;
      r2 = (r2 + 1) | 0;
      r5 = heapClassInst.heapU8[r5 + numDefine4];
      r5 = r5 & numDefine8;
      if (r5 !== 0) {
        continue repeat4;
      } else {
        break repeat4;
      }
    }
  }
  r1 = r1 & numDefine255;
  if (r1 === numDefine45) {
    r1 = heapClassInst.heap8[r2 + 1];
    r1 = r1 << numDefine2;
    r3 = (r1 + r3) | 0;
    r3 = heapClassInst.heapU16[(r3 + numDefine4) >> 1];
    r3 = r3 & numDefine263;
    if (r3 === 0) {
      label = numDefine5;
    } else {
      r2 = (r2 + 1) | 0;
      r3 = -1;
      label = numDefine8;
    }
  } else {
    label = numDefine5;
  }
  if (label === numDefine5) {
    r3 = 0;
  }
  heapClassInst.heap32[g0] = r2;
  heapClassInst.heap32[g0 + 1] = r4;
  strtoul(i7);
  r1 = commonVariable.rg0;
  if (!(r4 === 0)) {
    r4 = r4 >> numDefine2;
    r5 = heapClassInst.heap32[r4];
    if (!(r5 !== r2)) {
      heapClassInst.heap32[r4] = r0;
    }
  }
  if (r1 > -1) {
    r0 = 0;
    r0 = (r0 - r1) | 0;
    r0 = r3 === 0 ? r1 : r0;
    commonVariable.rg0 = r0;
    return;
  } else {
    errno(i7);
    r0 = commonVariable.rg0;
    if (!(r1 !== numDefineNeg83648)) {
      if (!(r3 === 0)) {
        r0 = r0 >> numDefine2;
        heapClassInst.heap32[r0] = 0;
        commonVariable.rg0 = r1;
        return;
      }
    }
    r1 = r0 >> numDefine2;
    r0 = numDefine83647;
    r2 = numDefineNeg83648;
    heapClassInst.heap32[r1] = numDefine34;
    r1 = r3 === 0 ? r0 : r2;
    commonVariable.rg0 = r1;
    return;
  }
}

function errno(sp: number): void {
  commonVariable.rg0 = llvmErrno;
}

function strtoul(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap8[r0];
  r2 = r1 << numDefine2;
  r3 = myCtype;
  r2 = (r2 + r3) | 0;
  r4 = heapClassInst.heap32[fp + 1];
  r2 = heapClassInst.heapU8[r2 + numDefine4];
  r2 = r2 & numDefine8;
  if (r2 === 0) {
    r2 = r0;
  } else {
    r2 = r0;
    repeat4: while (true) {
      r1 = heapClassInst.heap8[r2 + 1];
      r5 = r1 << numDefine2;
      r5 = (r5 + r3) | 0;
      r2 = (r2 + 1) | 0;
      r5 = heapClassInst.heapU8[r5 + numDefine4];
      r5 = r5 & numDefine8;
      if (r5 !== 0) {
        continue repeat4;
      } else {
        break repeat4;
      }
    }
  }
  r1 = r1 & numDefine255;
  if (r1 === numDefine43) {
    r2 = (r2 + 1) | 0;
    r1 = 0;
  } else {
    if (r1 === numDefine45) {
      r2 = (r2 + 1) | 0;
      r1 = 1;
    } else {
      r1 = 0;
    }
  }
  r3 = 0;
  r5 = r3;
  r6 = r3;
  r11 = -1;
  repeat14: while (true) {
    r8 = (r2 - r3) | 0;
    r7 = heapClassInst.heapU8[r8];
    if (r7 === 0) {
      break repeat14;
    } else {
      if (uint(r7) < uint(numDefine65)) {
        r9 = r7 & numDefine255;
        r10 = numDefine58;
        r7 = (r7 + numDefineNeg48) | 0;
        r7 = uint(r9) < uint(r10) ? r7 : r11;
        r7 = r7 & numDefine255;
        if (uint(r7) > uint(numDefine9)) {
          break repeat14;
        } else {
          r8 = r6 & numDefine255;
          r8 = (r8 * numDefine10) | 0;
          r7 = (r7 + r8) | 0;
          r6 = r6 >>> numDefine8;
          r8 = r7 >>> numDefine8;
          r6 = (r6 * numDefine10) | 0;
          r6 = (r8 + r6) | 0;
          r8 = numDefine77215;
          r9 = 1;
          r10 = r6 << numDefine8;
          r7 = r7 & numDefine255;
          r5 = uint(r6) > uint(r8) ? r9 : r5;
          r6 = r10 | r7;
          r3 = (r3 + -1) | 0;
          continue repeat14;
        }
      } else {
        break repeat14;
      }
    }
  }
  if (r3 === 0) {
    errno(i7);
    r6 = 0;
    r8 = commonVariable.rg0 >> numDefine2;
    heapClassInst.heap32[r8] = numDefine22;
    r8 = r0;
  }
  if (!(r4 === 0)) {
    r0 = r4 >> numDefine2;
    heapClassInst.heap32[r0] = r8;
  }
  if (r5 === 0) {
    r0 = 0;
    r0 = (r0 - r6) | 0;
    r0 = r1 === 0 ? r6 : r0;
    commonVariable.rg0 = r0;
    return;
  } else {
    errno(i7);
    r1 = commonVariable.rg0 >> numDefine2;
    heapClassInst.heap32[r1] = numDefine34;
    r1 = -1;
    commonVariable.rg0 = r1;
    return;
  }
}

function vPrintf(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let r16: number = 0;
  let r17: number = 0;
  let r18: number = 0;
  let r19: number = 0;
  let r20: number = 0;
  let r21: number = 0;
  let r22: number = 0;
  let r23: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg184;
  let g0 = i7 >> numDefine2;
  r0 = sp + numDefineNeg136;
  r1 = heapClassInst.heap32[fp + numDefine2];
  r2 = heapClassInst.heap32[fp];
  r3 = heapClassInst.heap32[fp + 1];
  r0 = (r0 + 1) | 0;
  heapClassInst.heap32[fp + -1] = r1;
  heapClassInst.heap32[fp + numDefineNeg2] = 0;
  repeat1: while (true) {
    r4 = heapClassInst.heapU8[r3];
    if (r4 === 0) {
      label = numDefine197;
      break repeat1;
    } else {
      r1 = 0;
      r5 = r4;
      repeat4: while (true) {
        r5 = r5 & numDefine255;
        if (r5 === 0) {
          break repeat4;
        } else {
          if (r5 !== numDefine37) {
            r5 = (r3 - r1) | 0;
            r5 = heapClassInst.heapU8[r5 + 1];
            r1 = (r1 + -1) | 0;
          } else {
            break repeat4;
          }
        }
      }
      r5 = 0;
      if (r1 !== 0) {
        r4 = (r5 - r1) | 0;
        if (r4 < 0) {
          label = numDefine198;
          break repeat1;
        } else {
          r6 = heapClassInst.heap32[fp + numDefineNeg2];
          r7 = (r6 - r1) | 0;
          if (uint(r7) < uint(r6)) {
            label = numDefine198;
            break repeat1;
          } else {
            r6 = (r3 - r1) | 0;
            r7 = r2 >> numDefine2;
            r8 = heapClassInst.heap32[r7 + 1];
            r7 = heapClassInst.heap32[r7];
            heapClassInst.heap32[g0] = r3;
            heapClassInst.heap32[g0 + 1] = r4;
            heapClassInst.heap32[g0 + numDefine2] = r7;
            functionTable[r8 >> numDefine2](i7);
            r4 = heapClassInst.heap32[fp + numDefineNeg2];
            r4 = (r4 - r1) | 0;
            r1 = (r3 - r1) | 0;
            heapClassInst.heap32[fp + numDefineNeg2] = r4;
            r4 = heapClassInst.heapU8[r1];
            r3 = r6;
          }
        }
      }
      r1 = r4 & numDefine255;
      if (r1 !== numDefine37) {
        continue repeat1;
      } else {
        r3 = (r3 + 1) | 0;
        r1 = numDefine32;
        r4 = r5;
        r6 = r5;
        r7 = r5;
        r8 = r5;
        r9 = r5;
        r10 = r5;
        r11 = r5;
        repeat15: while (true) {
          r12 = r4;
          r13 = r3;
          r14 = heapClassInst.heapU8[r13];
          r3 = (r13 + 1) | 0;
          heapClassInst.heap8[sp + numDefineNeg145] = r14;
          repeat17: do {
            if (r14 > numDefine99) {
              if (r14 > numDefine110) {
                if (r14 > numDefine114) {
                  if (r14 > numDefine119) {
                    if (r14 === numDefine122) {
                      label = numDefine50;
                      break repeat17;
                    } else {
                      label = numDefine44;
                      break repeat15;
                    }
                  } else {
                    label = numDefine41;
                    break repeat15;
                  }
                } else {
                  if (r14 === numDefine111) {
                    label = numDefine99;
                    break repeat15;
                  } else {
                    if (r14 === numDefine112) {
                      label = numDefine91;
                      break repeat15;
                    } else {
                      if (r14 === numDefine113) {
                        label = numDefine49;
                        break repeat17;
                      } else {
                        continue repeat1;
                      }
                    }
                  }
                }
              } else {
                if (r14 > numDefine104) {
                  if (r14 === numDefine105) {
                    label = numDefine102;
                    break repeat15;
                  } else {
                    if (r14 === numDefine106) {
                      label = numDefine49;
                      break repeat17;
                    } else {
                      if (r14 === numDefine108) {
                        label = numDefine50;
                        break repeat17;
                      } else {
                        continue repeat1;
                      }
                    }
                  }
                } else {
                  if (r14 === numDefine100) {
                    label = numDefine102;
                    break repeat15;
                  } else {
                    r4 = (r14 + numDefineNeg102) | 0;
                    if (uint(r4) < uint(numDefine2)) {
                      label = numDefine129;
                      break repeat15;
                    } else {
                      if (r14 === numDefine104) {
                        label = numDefine48;
                        break repeat17;
                      } else {
                        continue repeat1;
                      }
                    }
                  }
                }
              }
            } else {
              if (r14 > numDefine44) {
                if (r14 > numDefine75) {
                  if (r14 > numDefine97) {
                    label = numDefine26;
                    break repeat15;
                  } else {
                    if (r14 === numDefine76) {
                      label = numDefine49;
                      break repeat17;
                    } else {
                      label = numDefine25;
                      break repeat15;
                    }
                  }
                } else {
                  r4 = 1;
                  if (r14 === numDefine45) {
                    continue repeat15;
                  } else {
                    if (r14 === numDefine46) {
                      r4 = heapClassInst.heapU8[r3];
                      if (r4 !== numDefine42) {
                        r4 = sp + numDefineNeg144;
                        heapClassInst.heap32[g0] = r3;
                        heapClassInst.heap32[g0 + 1] = r4;
                        strtol(i7);
                        r14 = 0;
                        r11 = commonVariable.rg0 < 0 ? r14 : commonVariable.rg0;
                        r3 = heapClassInst.heap32[fp + numDefineNeg36];
                      } else {
                        r4 = sp + numDefineNeg4;
                        heapClassInst.heap32[g0] = r4;
                        heapClassInst.heap32[g0 + 1] = numDefine4;
                        myArgTest(i7);
                        r4 = commonVariable.rg0 >> numDefine2;
                        r4 = heapClassInst.heap32[r4];
                        r14 = 0;
                        r11 = r4 < 0 ? r14 : r4;
                        r3 = (r13 + numDefine2) | 0;
                      }
                      r8 = 1;
                      r4 = r12;
                      if (uint(r11) > uint(numDefine10240)) {
                        label = numDefine198;
                        break repeat1;
                      } else {
                        continue repeat15;
                      }
                    } else {
                      r4 = (r14 + numDefineNeg48) | 0;
                      if (uint(r4) < uint(numDefine10)) {
                        r4 = r8 & numDefine255;
                        if (r4 !== 0) {
                          label = numDefine198;
                          break repeat1;
                        } else {
                          r4 = sp + numDefineNeg144;
                          heapClassInst.heap32[g0] = r13;
                          heapClassInst.heap32[g0 + 1] = r4;
                          strtoul(i7);
                          r10 = commonVariable.rg0;
                          if (uint(r10) > uint(numDefine10240)) {
                            label = numDefine198;
                            break repeat1;
                          } else {
                            r8 = 0;
                            r4 = r12 & numDefine255;
                            r13 = heapClassInst.heapU8[sp + numDefineNeg145];
                            r14 = numDefine48;

                            r13 = r13 === r14 ? 1 : 0;

                            r4 = r4 === r8 ? 1 : 0;
                            r4 = r13 & r4;
                            r1 = r4 !== 0 ? r14 : r1;
                            r3 = heapClassInst.heap32[fp + numDefineNeg36];
                            r4 = r12;
                            continue repeat15;
                          }
                        }
                      } else {
                        continue repeat1;
                      }
                    }
                  }
                }
              } else {
                if (r14 > numDefine36) {
                  if (r14 === numDefine37) {
                    label = numDefine62;
                    break repeat15;
                  } else {
                    if (r14 === numDefine42) {
                      r4 = sp + numDefineNeg4;
                      heapClassInst.heap32[g0] = r4;
                      heapClassInst.heap32[g0 + 1] = numDefine4;
                      myArgTest(i7);
                      r4 = commonVariable.rg0 >> numDefine2;
                      r4 = heapClassInst.heap32[r4];
                      r13 = r4 >> numDefine31;
                      r14 = (r4 + r13) | 0;
                      r15 = 1;
                      r10 = r14 ^ r13;
                      r4 = r4 < 0 ? r15 : r12;
                      if (uint(r10) > uint(numDefine10240)) {
                        label = numDefine198;
                        break repeat1;
                      } else {
                        continue repeat15;
                      }
                    } else {
                      if (r14 === numDefine43) {
                        r7 = 1;
                        r4 = r12;
                        continue repeat15;
                      } else {
                        continue repeat1;
                      }
                    }
                  }
                } else {
                  if (r14 === 0) {
                    label = numDefine198;
                    break repeat1;
                  } else {
                    if (r14 === numDefine32) {
                      r6 = 1;
                      r4 = r12;
                      continue repeat15;
                    } else {
                      if (r14 === numDefine35) {
                        r5 = numDefine255;
                        label = numDefine48;
                      } else {
                        continue repeat1;
                      }
                    }
                  }
                }
              }
            }
          } while (false);
          switch (label) {
            case numDefine49:
              r9 = (r9 + 1) | 0;
              break;
            case numDefine48:
              r9 = (r9 + -1) | 0;
              r4 = r12;
              continue repeat15;
            default:
              break;
          }
          r9 = (r9 + 1) | 0;
          r4 = r12;
        }
        repeat71: do {
          switch (label) {
            case numDefine26:
              if (r14 === numDefine98) {
                r4 = 0;
                r13 = numDefine2;
                r14 = r4;
                r15 = r4;
                label = numDefine104;
                break repeat71;
              } else {
                if (r14 === numDefine99) {
                  r1 = sp + numDefineNeg4;
                  heapClassInst.heap32[g0] = r1;
                  heapClassInst.heap32[g0 + 1] = numDefine4;
                  myArgTest(i7);
                  r1 = commonVariable.rg0 >> numDefine2;
                  r1 = heapClassInst.heap32[r1];
                  heapClassInst.heap8[sp + numDefineNeg145] = r1;
                  label = numDefine62;
                  break repeat71;
                } else {
                  continue repeat1;
                }
              }

            case numDefine25:
              if (r14 === numDefine88) {
                label = numDefine92;
                break repeat71;
              } else {
                continue repeat1;
              }
            case numDefine44:
              if (r14 !== numDefine120) {
                continue repeat1;
              } else {
                r4 = 0;
                label = numDefine93;
                break repeat71;
              }
            case numDefine41:
              if (r14 === numDefine115) {
                r1 = sp + numDefineNeg4;
                heapClassInst.heap32[g0] = r1;
                heapClassInst.heap32[g0 + 1] = numDefine4;
                myArgTest(i7);
                r1 = commonVariable.rg0 >> numDefine2;
                r4 = twoEStr38684;
                r1 = heapClassInst.heap32[r1];
                r1 = r1 === 0 ? r4 : r1;
                heapClassInst.heap32[fp + numDefineNeg36] = r1;
                r4 = heapClassInst.heapU8[r1];
                repeat83: do {
                  if (r4 !== 0) {
                    r4 = (r1 + 1) | 0;
                    r14 = 0;
                    while (true) {
                      r1 = (r14 + 1) | 0;
                      r6 = heapClassInst.heapU8[r4 + r14];
                      r14 = r1;
                      if (!(r6 !== 0)) {
                        break repeat83;
                      }
                    }
                  } else {
                    r1 = 0;
                  }
                } while (false);
                r16 = 0;
                r4 = r8 & numDefine255;

                r4 = r4 !== r16 ? 1 : 0;

                r14 = uint(r1) > uint(r11) ? 1 : 0;
                r4 = r4 & r14;
                r14 = numDefine32;
                r4 = r4 !== 0 ? r11 : r1;
                r1 = r14;
                r8 = r16;
                r11 = r16;
                label = numDefine69;
                break repeat71;
              } else {
                if (r14 === numDefine117) {
                  r4 = 0;
                  r13 = numDefine10;
                  r14 = r4;
                  r15 = r4;
                  label = numDefine104;
                  break repeat71;
                } else {
                  continue repeat1;
                }
              }

            case numDefine99:
              r4 = r5 & numDefine255;
              if (r4 !== 0) {
                r5 = 1;
                r4 = 0;
                r13 = numDefine8;
                r14 = numDefine48;
                heapClassInst.heap8[sp + numDefineNeg135] = r14;
                r14 = r4;
                r15 = r5;
                label = numDefine104;
                break repeat71;
              } else {
                r4 = 0;
                r13 = numDefine8;
                r14 = r4;
                r5 = r4;
                r15 = r4;
                label = numDefine104;
                break repeat71;
              }
              break;
            case numDefine91:
              r14 = numDefine120;
              r5 = numDefine2;
              r9 = 1;
              heapClassInst.heap8[sp + numDefineNeg145] = r14;
              label = numDefine92;
              break repeat71;
            case numDefine102:
              r4 = 0;
              r14 = 1;
              r13 = numDefine10;
              r15 = r4;
              label = numDefine104;
              break repeat71;
            case numDefine129:
              r4 = sp + numDefineNeg4;
              heapClassInst.heap32[g0] = r4;
              heapClassInst.heap32[g0 + 1] = numDefine8;
              myArgTest(i7);
              f0 = llvmReadDouble(commonVariable.rg0);
              heapClassInst.heap32[fp + numDefineNeg36] = r0;
              r4 = numDefine103;

              r4 = r14 === r4 ? 1 : 0;
              r8 = r8 & numDefine255;
              r16 = 1;
              r9 = numDefine6;
              r10 = r10 === 0 ? r16 : r10;
              r11 = r8 === 0 ? r9 : r11;
              r4 = r4 & 1;
              f1 = 0;
              r9 = r7 & numDefine255;
              r13 = 0;
              llvmWriteDouble(i7, f0);
              heapClassInst.heap32[g0 + numDefine2] = r0;
              heapClassInst.heap32[g0 + numDefine3] = numDefine127;
              heapClassInst.heap32[g0 + numDefine4] = r10;
              heapClassInst.heap32[g0 + numDefine5] = r11;
              heapClassInst.heap32[g0 + numDefine6] = r4;

              r4 = r9 !== r13 ? 1 : 0;

              r16 = f0 < f1 ? 1 : 0;
              r4 = r4 | r16;
              r16 = r4 & 1;
              dtostr(i7);
              r4 = commonVariable.rg0;
              repeat98: do {
                if (r8 !== 0) {
                  r8 = heapClassInst.heap32[fp + numDefineNeg36];
                  r15 = r13;
                  repeat100: while (true) {
                    r17 = heapClassInst.heapU8[r8 + r13];
                    if (r17 === 0) {
                      label = numDefine151;
                      break repeat100;
                    } else {
                      r18 = (r8 + r13) | 0;
                      if (r17 === numDefine46) {
                        label = numDefine142;
                        break repeat100;
                      } else {
                        r17 = heapClassInst.heapU8[r18 + 1];
                        if (r17 === 0) {
                          label = numDefine151;
                          break repeat100;
                        } else {
                          r19 = r15 << numDefine2;
                          if (r17 !== numDefine46) {
                            r17 = heapClassInst.heapU8[r18 + numDefine2];
                            if (r17 === 0) {
                              label = numDefine151;
                              break repeat100;
                            } else {
                              if (r17 !== numDefine46) {
                                r17 = heapClassInst.heapU8[r18 + numDefine3];
                                if (r17 === 0) {
                                  label = numDefine151;
                                  break repeat100;
                                } else {
                                  if (r17 === numDefine46) {
                                    label = numDefine143;
                                    break repeat100;
                                  } else {
                                    r15 = (r15 + 1) | 0;
                                    r13 = (r13 + numDefine4) | 0;
                                  }
                                }
                              } else {
                                label = numDefine138;
                                break repeat100;
                              }
                            }
                          } else {
                            label = numDefine135;
                            break repeat100;
                          }
                        }
                      }
                    }
                  }
                  repeat110: do {
                    switch (label) {
                      case numDefine142:
                        if (r18 === 0) {
                          label = numDefine151;
                          break repeat110;
                        } else {
                          label = numDefine144;
                          break repeat110;
                        }
                      case numDefine143:
                        r18 = (r18 + numDefine3) | 0;
                        label = numDefine144;
                        break repeat110;
                      case numDefine138:
                        r4 = r19 | numDefine2;
                        r18 = (r8 + r4) | 0;
                        label = numDefine144;
                        break repeat110;
                      case numDefine135:
                        r4 = r19 | 1;
                        r18 = (r8 + r4) | 0;
                        label = numDefine144;
                        break;
                      default:
                        break;
                    }
                  } while (false);
                  switch (label) {
                    case numDefine151:
                      r5 = r5 & numDefine255;
                      if (r5 === 0) {
                        break repeat98;
                      } else {
                        r5 = numDefine46;
                        heapClassInst.heap8[r8 + r4] = r5;
                        r5 = heapClassInst.heap32[fp + numDefineNeg36];
                        r4 = (r4 + r5) | 0;
                        r5 = 0;
                        heapClassInst.heap8[r4 + 1] = r5;
                      }

                    case numDefine144:
                      if (r11 !== 0) {
                        label = numDefine146;
                      } else {
                        r4 = r5 & numDefine255;
                        if (r4 !== 0) {
                          label = numDefine146;
                        } else {
                          label = numDefine147;
                        }
                      }
                      if (label === numDefine146) {
                        r18 = (r18 + 1) | 0;
                      }
                      repeat123: while (true) {
                        r4 = r11;
                        if (r4 !== 0) {
                          r11 = (r4 + -1) | 0;
                          r5 = (r18 + 1) | 0;
                          r8 = heapClassInst.heapU8[r18 + 1];
                          r18 = r5;
                          if (r8 !== 0) {
                            label = numDefine147;
                          } else {
                            label = numDefine149;
                            break repeat123;
                          }
                        } else {
                          label = numDefine150;
                          break repeat123;
                        }
                      }
                      if (label === numDefine149) {
                        r18 = r5;
                      }
                      r5 = 0;
                      heapClassInst.heap8[r18] = r5;
                      r11 = r4;
                    default:
                      break;
                  }
                }
              } while (false);
              repeat130: do {
                if (!(r14 !== numDefine103)) {
                  r4 = heapClassInst.heap32[fp + numDefineNeg36];
                  r5 = 0;
                  r8 = r5;
                  repeat132: while (true) {
                    r14 = heapClassInst.heapU8[r4 + r5];
                    if (r14 === 0) {
                      break repeat130;
                    } else {
                      r13 = (r4 + r5) | 0;
                      if (r14 === numDefine46) {
                        label = numDefine166;
                        break repeat132;
                      } else {
                        r14 = heapClassInst.heapU8[r13 + 1];
                        if (r14 === 0) {
                          break repeat130;
                        } else {
                          r15 = r8 << numDefine2;
                          if (r14 !== numDefine46) {
                            r14 = heapClassInst.heapU8[r13 + numDefine2];
                            if (r14 === 0) {
                              break repeat130;
                            } else {
                              if (r14 !== numDefine46) {
                                r14 = heapClassInst.heapU8[r13 + numDefine3];
                                if (r14 === 0) {
                                  break repeat130;
                                } else {
                                  if (r14 === numDefine46) {
                                    label = numDefine167;
                                    break repeat132;
                                  } else {
                                    r8 = (r8 + 1) | 0;
                                    r5 = (r5 + numDefine4) | 0;
                                  }
                                }
                              } else {
                                label = numDefine162;
                                break repeat132;
                              }
                            }
                          } else {
                            label = numDefine159;
                            break repeat132;
                          }
                        }
                      }
                    }
                  }
                  switch (label) {
                    case numDefine166:
                      if (r13 === 0) {
                        break repeat130;
                      }

                    case numDefine167:
                      r13 = (r13 + numDefine3) | 0;
                      break;
                    case numDefine162:
                      r5 = r15 | numDefine2;
                      r13 = (r4 + r5) | 0;
                      break;
                    case numDefine159:
                      r5 = r15 | 1;
                      r13 = (r4 + r5) | 0;
                      break;
                    default:
                      break;
                  }
                  r4 = 0;
                  r5 = r13;
                  repeat148: while (true) {
                    r8 = heapClassInst.heapU8[r5];
                    if (r8 !== numDefine101) {
                      if (r8 !== 0) {
                        r8 = r4 << numDefine2;
                        r14 = heapClassInst.heapU8[r5 + 1];
                        if (r14 !== numDefine101) {
                          if (r14 === 0) {
                            label = numDefine171;
                            break repeat148;
                          } else {
                            r14 = heapClassInst.heapU8[r5 + numDefine2];
                            if (r14 !== numDefine101) {
                              if (r14 === 0) {
                                label = numDefine171;
                                break repeat148;
                              } else {
                                r14 = heapClassInst.heapU8[r5 + numDefine3];
                                if (r14 !== numDefine101) {
                                  if (r14 === 0) {
                                    label = numDefine171;
                                    break repeat148;
                                  } else {
                                    r4 = (r4 + 1) | 0;
                                    r5 = (r5 + numDefine4) | 0;
                                  }
                                } else {
                                  label = numDefine179;
                                  break repeat148;
                                }
                              }
                            } else {
                              label = numDefine176;
                              break repeat148;
                            }
                          }
                        } else {
                          label = numDefine173;
                          break repeat148;
                        }
                      } else {
                        label = numDefine171;
                        break repeat148;
                      }
                    } else {
                      label = numDefine182;
                      break repeat148;
                    }
                  }
                  switch (label) {
                    case numDefine171:
                      r5 = 0;
                      break;
                    case numDefine179:
                      r4 = r8 | numDefine3;
                      r5 = (r13 + r4) | 0;
                      break;
                    case numDefine176:
                      r4 = r8 | numDefine2;
                      r5 = (r13 + r4) | 0;
                      break;
                    case numDefine173:
                      r4 = r8 | 1;
                      r5 = (r13 + r4) | 0;
                      break;
                    default:
                      break;
                  }
                  repeat163: while (true) {
                    r4 = (r13 + 1) | 0;
                    r8 = heapClassInst.heapU8[r13 + 1];
                    r13 = r4;
                    if (!(r8 !== 0)) {
                      break repeat163;
                    }
                  }
                  r4 = r5 === 0 ? r4 : r5;
                  repeat166: while (true) {
                    r8 = heapClassInst.heapU8[r4 + -1];
                    r4 = (r4 + -1) | 0;
                    if (!(r8 === numDefine48)) {
                      break repeat166;
                    }
                  }
                  r14 = (r4 + 1) | 0;
                  r4 = r8 === numDefine46 ? r4 : r14;
                  r8 = 0;
                  heapClassInst.heap8[r4] = r8;
                  if (!(r5 === 0)) {
                    heapClassInst.heap32[g0] = r4;
                    heapClassInst.heap32[g0 + 1] = r5;
                    strcpy(i7);
                  }
                }
              } while (false);
              r4 = r7 | r6;
              r4 = r4 & numDefine255;
              if (!(r4 === 0)) {
                if (!(f0 < f1)) {
                  r4 = heapClassInst.heap32[fp + numDefineNeg36];
                  r5 = (r4 + -1) | 0;
                  r8 = numDefine32;
                  r14 = numDefine43;
                  r8 = r9 === 0 ? r8 : r14;
                  heapClassInst.heap32[fp + numDefineNeg36] = r5;
                  heapClassInst.heap8[r4 + -1] = r8;
                }
              }
              r4 = heapClassInst.heap32[fp + numDefineNeg36];
              r5 = heapClassInst.heapU8[r4];
              repeat175: do {
                if (r5 !== 0) {
                  r5 = (r4 + 1) | 0;
                  r8 = 0;
                  while (true) {
                    r4 = (r8 + 1) | 0;
                    r14 = heapClassInst.heapU8[r5 + r8];
                    r8 = r4;
                    if (!(r14 !== 0)) {
                      break repeat175;
                    }
                  }
                } else {
                  r4 = 0;
                }
              } while (false);
              r10 = uint(r10) < uint(r4) ? r4 : r10;
              r14 = numDefine48;
              r5 = 0;
              r8 = r5;
              label = numDefine69;
            default:
              break;
          }
        } while (false);
        switch (label) {
          case numDefine62:
            r1 = heapClassInst.heap32[fp + numDefineNeg2];
            if (r1 === -1) {
              label = numDefine198;
              break repeat1;
            } else {
              r1 = r2 >> numDefine2;
              r4 = heapClassInst.heap32[r1 + 1];
              r1 = heapClassInst.heap32[r1];
              r5 = sp + numDefineNeg145;
              heapClassInst.heap32[g0] = r5;
              heapClassInst.heap32[g0 + 1] = 1;
              heapClassInst.heap32[g0 + numDefine2] = r1;
              functionTable[r4 >> numDefine2](i7);
              r1 = heapClassInst.heap32[fp + numDefineNeg2];
              r1 = (r1 + 1) | 0;
              heapClassInst.heap32[fp + numDefineNeg2] = r1;
              continue repeat1;
            }
          case numDefine92:
            r4 = r14 & numDefine255;
            r13 = numDefine88;

            r4 = r4 === r13 ? 1 : 0;
            r4 = r4 & 1;
            label = numDefine93;
            break;
          default:
            break;
        }
        if (label === numDefine93) {
          r5 = r5 & numDefine255;
          if (r5 !== 0) {
            r13 = numDefine48;
            r5 = numDefine2;
            heapClassInst.heap8[sp + numDefineNeg135] = r13;
            heapClassInst.heap8[sp + numDefineNeg134] = r14;
            r15 = r5;
          } else {
            r5 = 0;
            r15 = r5;
          }
          if (uint(r11) > uint(r10)) {
            r14 = 0;
            r13 = numDefine16;
            r10 = r11;
            label = numDefine104;
          } else {
            r14 = 0;
            r13 = numDefine16;
            label = numDefine104;
          }
        }
        repeat194: do {
          if (label === numDefine104) {
            heapClassInst.heap32[fp + numDefineNeg36] = r0;
            r16 = sp + numDefineNeg4;
            heapClassInst.heap32[g0] = r16;
            heapClassInst.heap32[g0 + 1] = numDefine4;
            myArgTest(i7);
            r17 = commonVariable.rg0 >> numDefine2;
            r18 = r14 & numDefine255;
            r16 = 0;
            r17 = heapClassInst.heap32[r17];

            r18 = r18 !== r16 ? 1 : 0;

            r19 = r17 < r16 ? 1 : 0;
            r20 = (r16 - r17) | 0;
            r18 = r18 & r19;
            r9 = r9 << numDefine24;
            r17 = r18 !== 0 ? r20 : r17;
            r9 = r9 >> numDefine24;
            r19 = r17 & numDefine65535;
            r17 = r9 < 0 ? r19 : r17;
            r19 = heapClassInst.heap32[fp + numDefineNeg36];
            r20 = r17 & numDefine255;
            r21 = numDefine2;
            r9 = r9 < -1 ? r20 : r17;
            r17 = r18 !== 0 ? r21 : r14;
            r14 = (r19 + r15) | 0;
            heapClassInst.heap8[r14 + numDefine122] = r16;
            if (r9 !== 0) {
              r18 = (r13 + -1) | 0;
              r19 = numDefine35;
              r20 = numDefine10;
              r18 = uint(r18) > uint(r19) ? r20 : r13;
              r4 = r4 & numDefine255;
              r13 = numDefine39;
              r19 = numDefine7;
              r4 = r4 === 0 ? r13 : r19;
              r19 = (r15 + numDefine121) | 0;
              r20 = numDefineNeg122;
              repeat198: while (true) {
                r13 = Math.floor(uint(r9) % uint(r18));
                r13 = (r13 + numDefine48) | 0;
                r22 = r13 & numDefine255;
                r23 = numDefine57;
                r22 = uint(r22) > uint(r23) ? r4 : r16;
                r23 = (r20 + 1) | 0;
                r13 = (r13 + r22) | 0;
                r20 = (r14 - r20) | 0;
                heapClassInst.heap8[r20 + -1] = r13;
                if (r19 <= r15) {
                  break repeat198;
                } else {
                  r9 = Math.floor(uint(r9) / uint(r18));
                  r19 = (r19 + -1) | 0;
                  r20 = r23;
                  if (!(r9 !== 0)) {
                    break repeat198;
                  }
                }
              }
              r18 = (r23 + numDefine122) | 0;
              r9 = (r14 - r23) | 0;
            } else {
              r4 = (r15 + r19) | 0;
              r13 = numDefine48;
              r9 = (r4 + numDefine121) | 0;
              r18 = 1;
              heapClassInst.heap8[r4 + numDefine121] = r13;
            }
            repeat204: do {
              if (!(r9 === r14)) {
                if (uint(r9) <= uint(r14)) {
                  if (!(r18 === -1)) {
                    r4 = (r16 - r18) | 0;
                    while (true) {
                      r13 = r4;
                      r19 = (r9 - r13) | 0;
                      r4 = (r13 + 1) | 0;
                      r20 = (r14 - r13) | 0;
                      r19 = heapClassInst.heapU8[r19];
                      heapClassInst.heap8[r20] = r19;
                      if (!(r13 !== 0)) {
                        break repeat204;
                      }
                    }
                  }
                } else {
                  if (!(r18 === -1)) {
                    r4 = (r9 + 1) | 0;
                    r9 = r18;
                    while (true) {
                      heapClassInst.heap8[r14] = r13;
                      if (r9 === 0) {
                        break repeat204;
                      } else {
                        r13 = heapClassInst.heapU8[r4];
                        r4 = (r4 + 1) | 0;
                        r9 = (r9 + -1) | 0;
                        r14 = (r14 + 1) | 0;
                      }
                    }
                  }
                }
              }
            } while (false);
            r4 = 1;

            r4 = r18 !== r4 ? 1 : 0;
            r4 = r4 & 1;
            r14 = r8 ^ 1;
            r4 = r4 | r14;
            r4 = r4 & numDefine255;
            if (r4 !== 0) {
              label = numDefine122;
            } else {
              r4 = heapClassInst.heap32[fp + numDefineNeg36];
              r4 = heapClassInst.heapU8[r4 + r15];
              if (r4 !== numDefine48) {
                label = numDefine122;
              } else {
                r4 = r5 << numDefine24;
                r5 = 0;

                r4 = r4 >> numDefine24;

                r14 = r11 === r5 ? 1 : 0;

                r4 = r4 > r5 ? 1 : 0;
                r4 = r14 | r4;
                r4 = r4 !== 0 ? r5 : r15;
                label = numDefine123;
              }
            }
            if (label === numDefine122) {
              r4 = (r18 + r15) | 0;
            }
            r14 = r17 & numDefine255;
            if (r14 === numDefine2) {
              r6 = heapClassInst.heap32[fp + numDefineNeg36];
              r7 = (r6 + -1) | 0;
              r4 = (r4 + 1) | 0;
              r14 = numDefine48;
              r16 = numDefine45;
              heapClassInst.heap32[fp + numDefineNeg36] = r7;
              heapClassInst.heap8[r6 + -1] = r16;
              r16 = r21;
            } else {
              if (r14 !== 0) {
                r14 = r7 | r6;
                r14 = r14 & numDefine255;
                if (!(r14 === 0)) {
                  r6 = heapClassInst.heap32[fp + numDefineNeg36];
                  r16 = (r6 + -1) | 0;
                  r7 = r7 & numDefine255;
                  r9 = numDefine32;
                  r13 = numDefine43;
                  r4 = (r4 + 1) | 0;
                  r14 = numDefine48;
                  r7 = r7 === 0 ? r9 : r13;
                  heapClassInst.heap32[fp + numDefineNeg36] = r16;
                  heapClassInst.heap8[r6 + -1] = r7;
                  r16 = r17;
                  break repeat194;
                }
              }
              r14 = numDefine48;
            }
          }
        } while (false);
        r6 = heapClassInst.heap32[fp + numDefineNeg36];
        r7 = r11 | r10;
        if (r7 !== 0) {
          r7 = 0;
          r5 = r5 << numDefine24;
          r5 = r5 >> numDefine24;
          if (r5 < 1) {
            r9 = r16 & numDefine255;

            r5 = r9 !== r7 ? 1 : 0;
            r5 = r5 & 1;
            if (r9 !== 0) {
              label = numDefine75;
            } else {
              label = numDefine76;
            }
          } else {
            label = numDefine75;
          }
          if (label === numDefine75) {
            r4 = (r4 - r5) | 0;
            r10 = (r10 - r5) | 0;
            r9 = (r6 + r5) | 0;
            heapClassInst.heap32[fp + numDefineNeg36] = r9;
          }
          r8 = r8 & numDefine255;

          r9 = r8 !== r7 ? 1 : 0;

          r7 = r10 === r7 ? 1 : 0;
          r7 = r9 & r7;
          r7 = r7 !== 0 ? r11 : r10;
          r8 = r8 === 0 ? r4 : r11;
          r9 = r12 & numDefine255;
          if (!(r9 !== 0)) {
            r10 = r1 & numDefine255;
            if (!(r10 !== numDefine32)) {
              r11 = sp + numDefineNeg8;
              r12 = (r7 - r8) | 0;
              heapClassInst.heap32[g0] = r11;
              heapClassInst.heap32[g0 + 1] = r2;
              heapClassInst.heap32[g0 + numDefine2] = r12;
              heapClassInst.heap32[g0 + numDefine3] = r10;
              writePad(i7);
              r10 = commonVariable.rg0;
              if (r10 !== 0) {
                label = numDefine198;
                break repeat1;
              }
            }
          }
          if (!(r5 === 0)) {
            if (r5 < 0) {
              label = numDefine198;
              break repeat1;
            } else {
              r10 = heapClassInst.heap32[fp + numDefineNeg2];
              r11 = (r10 + r5) | 0;
              if (uint(r11) < uint(r10)) {
                label = numDefine198;
                break repeat1;
              } else {
                r10 = r2 >> numDefine2;
                r11 = heapClassInst.heap32[r10 + 1];
                r10 = heapClassInst.heap32[r10];
                heapClassInst.heap32[g0] = r6;
                heapClassInst.heap32[g0 + 1] = r5;
                heapClassInst.heap32[g0 + numDefine2] = r10;
                functionTable[r11 >> numDefine2](i7);
                r6 = heapClassInst.heap32[fp + numDefineNeg2];
                r5 = (r6 + r5) | 0;
                heapClassInst.heap32[fp + numDefineNeg2] = r5;
              }
            }
          }
          if (!(r9 !== 0)) {
            r5 = r1 & numDefine255;
            if (!(r5 === numDefine32)) {
              r6 = sp + numDefineNeg8;
              r10 = (r7 - r8) | 0;
              heapClassInst.heap32[g0] = r6;
              heapClassInst.heap32[g0 + 1] = r2;
              heapClassInst.heap32[g0 + numDefine2] = r10;
              heapClassInst.heap32[g0 + numDefine3] = r5;
              writePad(i7);
              r5 = commonVariable.rg0;
              if (r5 !== 0) {
                label = numDefine198;
                break repeat1;
              }
            }
          }
          r5 = sp + numDefineNeg8;
          r6 = (r8 - r4) | 0;
          heapClassInst.heap32[g0] = r5;
          heapClassInst.heap32[g0 + 1] = r2;
          heapClassInst.heap32[g0 + numDefine2] = r6;
          heapClassInst.heap32[g0 + numDefine3] = r14;
          writePad(i7);
          r14 = commonVariable.rg0;
          if (r14 !== 0) {
            label = numDefine198;
            break repeat1;
          } else {
            if (r4 < 0) {
              label = numDefine198;
              break repeat1;
            } else {
              r14 = heapClassInst.heap32[fp + numDefineNeg2];
              r6 = (r14 + r4) | 0;
              if (uint(r6) < uint(r14)) {
                label = numDefine198;
                break repeat1;
              } else {
                r14 = r2 >> numDefine2;
                r6 = heapClassInst.heap32[r14 + 1];
                r14 = heapClassInst.heap32[r14];
                r10 = heapClassInst.heap32[fp + numDefineNeg36];
                heapClassInst.heap32[g0] = r10;
                heapClassInst.heap32[g0 + 1] = r4;
                heapClassInst.heap32[g0 + numDefine2] = r14;
                functionTable[r6 >> numDefine2](i7);
                r14 = heapClassInst.heap32[fp + numDefineNeg2];
                r4 = (r14 + r4) | 0;
                heapClassInst.heap32[fp + numDefineNeg2] = r4;
                if (r9 === 0) {
                  continue repeat1;
                } else {
                  r4 = (r7 - r8) | 0;
                  r14 = r1 & numDefine255;
                  heapClassInst.heap32[g0] = r5;
                  heapClassInst.heap32[g0 + 1] = r2;
                  heapClassInst.heap32[g0 + numDefine2] = r4;
                  heapClassInst.heap32[g0 + numDefine3] = r14;
                  writePad(i7);
                  r4 = commonVariable.rg0;
                  if (r4 === 0) {
                    continue repeat1;
                  } else {
                    label = numDefine198;
                    break repeat1;
                  }
                }
              }
            }
          }
        } else {
          if (r4 < 0) {
            label = numDefine198;
            break repeat1;
          } else {
            r14 = heapClassInst.heap32[fp + numDefineNeg2];
            r1 = (r14 + r4) | 0;
            if (uint(r1) < uint(r14)) {
              label = numDefine198;
              break repeat1;
            } else {
              r14 = r2 >> numDefine2;
              r1 = heapClassInst.heap32[r14 + 1];
              r14 = heapClassInst.heap32[r14];
              heapClassInst.heap32[g0] = r6;
              heapClassInst.heap32[g0 + 1] = r4;
              heapClassInst.heap32[g0 + numDefine2] = r14;
              functionTable[r1 >> numDefine2](i7);
              r14 = heapClassInst.heap32[fp + numDefineNeg2];
              r4 = (r14 + r4) | 0;
              heapClassInst.heap32[fp + numDefineNeg2] = r4;
              continue repeat1;
            }
          }
        }
      }
    }
  }
  switch (label) {
    case numDefine197:
      r0 = heapClassInst.heap32[fp + numDefineNeg2];
      commonVariable.rg0 = r0;
      return;
    case numDefine198:
      r0 = -1;
      commonVariable.rg0 = r0;
      return;
    default:
      break;
  }
}

function writePad(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine2];
  if (r0 > 0) {
    r1 = heapClassInst.heap32[fp];
    r1 = r1 >> numDefine2;
    r2 = heapClassInst.heap32[r1];
    r2 = (r2 + r0) | 0;
    if (uint(r2) >= uint(r0)) {
      r2 = heapClassInst.heap32[fp + 1];
      r3 = heapClassInst.heap32[fp + numDefine3];
      if (uint(r0) > uint(numDefine15)) {
        r4 = numDefine48;

        r4 = r3 === r4 ? 1 : 0;
        r4 = r4 & 1;
        r5 = zl8padLine;
        r4 = r4 << numDefine5;
        r4 = (r5 + r4) | 0;
        r5 = 0;
        repeat7: while (true) {
          r6 = r2 >> numDefine2;
          r7 = heapClassInst.heap32[r6 + 1];
          r6 = heapClassInst.heap32[r6];
          heapClassInst.heap32[g0] = r4;
          heapClassInst.heap32[g0 + 1] = numDefine16;
          heapClassInst.heap32[g0 + numDefine2] = r6;
          r5 = (r5 + numDefineNeg16) | 0;
          functionTable[r7 >> numDefine2](i7);
          r6 = (r0 + r5) | 0;
          if (!(uint(r6) > uint(numDefine15))) {
            break repeat7;
          }
        }
        r0 = 0;
        r4 = (r0 - r5) | 0;
        if (r6 === 0) {
          label = numDefine11;
        } else {
          r0 = r6;
          label = numDefine10;
        }
      } else {
        r4 = 0;
        label = numDefine10;
      }
      if (label === numDefine10) {
        r5 = numDefine48;
        r2 = r2 >> numDefine2;

        r3 = r3 === r5 ? 1 : 0;
        r3 = r3 & 1;
        r5 = heapClassInst.heap32[r2 + 1];
        r2 = heapClassInst.heap32[r2];
        r6 = zl8padLine;
        r3 = r3 << numDefine5;
        r3 = (r6 + r3) | 0;
        heapClassInst.heap32[g0] = r3;
        heapClassInst.heap32[g0 + 1] = r0;
        heapClassInst.heap32[g0 + numDefine2] = r2;
        r4 = (r4 + r0) | 0;
        functionTable[r5 >> numDefine2](i7);
      }
      r0 = heapClassInst.heap32[r1];
      r0 = (r0 + r4) | 0;
      heapClassInst.heap32[r1] = r0;
      r0 = 0;
    } else {
      r0 = -1;
    }
  } else {
    r0 = 0;
  }
  commonVariable.rg0 = r0;
  return;
}

function memcpy(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = heapClassInst.heap32[fp + numDefine2];
  r3 = r1 ^ r0;
  r3 = r3 & numDefine3;
  repeat1: do {
    if (r3 !== 0) {
      label = numDefine2;
    } else {
      if (uint(r2) > uint(numDefine4)) {
        r3 = r0 & numDefine3;
        if (r3 !== 0) {
          r3 = (r3 + numDefineNeg5) | 0;
          r4 = r2 ^ -1;
          r3 = uint(r3) < uint(r4) ? r4 : r3;
          r4 = (r3 + r2) | 0;
          r3 = r3 ^ -1;
          r4 = (r4 + 1) | 0;
          r6 = (r1 + r3) | 0;
          r5 = (r0 + r3) | 0;
          r3 = r0 | numDefineNeg4;
          r7 = r0;
          repeat6: while (true) {
            if (r3 === 0) {
              break repeat6;
            } else {
              if (r2 === 0) {
                label = numDefine19;
                break repeat1;
              } else {
                r8 = heapClassInst.heapU8[r1];
                r2 = (r2 + -1) | 0;
                r3 = (r3 + 1) | 0;
                r1 = (r1 + 1) | 0;
                r9 = (r7 + 1) | 0;
                heapClassInst.heap8[r7] = r8;
                r7 = r9;
              }
            }
          }
          if (r4 === -1) {
            label = numDefine19;
            break repeat1;
          } else {
            r2 = r4;
            r1 = r6;
          }
        } else {
          r5 = r0;
        }
        if (uint(r2) > uint(numDefine3)) {
          r6 = r5;
          r4 = r1;
          repeat16: while (true) {
            r7 = r4 >> numDefine2;
            r2 = (r2 + numDefineNeg4) | 0;
            r4 = (r4 + numDefine4) | 0;
            r3 = (r6 + numDefine4) | 0;
            r6 = r6 >> numDefine2;
            r7 = heapClassInst.heap32[r7];
            heapClassInst.heap32[r6] = r7;
            r6 = r3;
            if (uint(r2) > uint(numDefine3)) {
              continue repeat16;
            } else {
              label = numDefine15;
              break repeat1;
            }
          }
        } else {
          r4 = r1;
          r3 = r5;
          label = numDefine15;
        }
      } else {
        label = numDefine2;
      }
    }
  } while (false);
  if (label === numDefine2) {
    r3 = 0;
    r4 = r3;
    r5 = r0;
    label = numDefine15;
  }
  repeat21: do {
    if (label === numDefine15) {
      if (!(r2 === 0)) {
        if (r3 !== 0) {
          r1 = r4;
          r5 = r3;
        }
        repeat26: while (true) {
          r3 = heapClassInst.heapU8[r1];
          r2 = (r2 + -1) | 0;
          r4 = (r5 + 1) | 0;
          r1 = (r1 + 1) | 0;
          heapClassInst.heap8[r5] = r3;
          r5 = r4;
          if (r2 !== 0) {
            continue repeat26;
          } else {
            break repeat21;
          }
        }
      }
    }
  } while (false);
  commonVariable.rg0 = r0;
  return;
}

function vsnprintf(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg40;
  let g0 = i7 >> numDefine2;
  r0 = sp + numDefineNeg16;
  r1 = heapClassInst.heap32[fp + 1];
  r2 = r0 >> numDefine2;
  r3 = heapClassInst.heap32[fp];
  heapClassInst.heap32[r2 + 1] = 0;
  r4 = (r1 + -1) | 0;
  r5 = 0;
  r6 = sp + numDefineNeg24;
  r7 = r1 === 0 ? r5 : r4;
  heapClassInst.heap32[fp + numDefineNeg4] = r3;
  r8 = r6 >> numDefine2;
  r9 = swriteIndex.swriteIndexNew;
  heapClassInst.heap32[r2 + numDefine2] = r7;
  heapClassInst.heap32[r8 + 1] = r9;
  heapClassInst.heap32[fp + numDefineNeg6] = r0;
  r0 = heapClassInst.heap32[fp + numDefine2];
  r2 = heapClassInst.heap32[fp + numDefine3];
  heapClassInst.heap32[g0] = r6;
  heapClassInst.heap32[g0 + 1] = r0;
  heapClassInst.heap32[g0 + numDefine2] = r2;
  vPrintf(i7);
  r0 = commonVariable.rg0;
  if (!(r3 === 0)) {
    if (!(r1 === 0)) {
      if (!(r0 < 0)) {
        if (!(r1 === -1)) {
          if (!(uint(r0) < uint(r1))) {
            heapClassInst.heap8[r3 + r4] = r5;
            commonVariable.rg0 = r0;
            return;
          }
        }
        heapClassInst.heap8[r3 + r0] = r5;
      }
    }
  }
  commonVariable.rg0 = r0;
  return;
}

function alert(message: string): void {}

function tlsfMalloc(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heap32[fp];
  r2 = (r0 + -1) | 0;
  if (uint(r2) < uint(numDefine41823)) {
    r0 = (r0 + numDefine7) | 0;
    r0 = r0 & numDefineNeg8;
    r2 = numDefine12;
    r0 = uint(r0) < uint(r2) ? r2 : r0;
  } else {
    r0 = 0;
  }
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = r0;
  blockLocateFree(i7);
  r2 = commonVariable.rg0;
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = r2;
  heapClassInst.heap32[g0 + numDefine2] = r0;
  r0 = sCurrentMemory;
  blockPrepareUsed(i7);
  r1 = commonVariable.rg0;
  r2 = r2 >> numDefine2;
  r0 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + 1];
  r3 = heapClassInst.heap32[r0];
  r2 = r2 & numDefineNeg4;
  r2 = (r3 + r2) | 0;
  r3 = sMaxMemory;
  r3 = r3 >> numDefine2;
  heapClassInst.heap32[r0] = r2;
  r0 = heapClassInst.heap32[r3];
  if (!(uint(r2) <= uint(r0))) {
    heapClassInst.heap32[r3] = r2;
  }
  commonVariable.rg0 = r1;
  return;
}

function blockLocateFree(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  repeat1: do {
    if (!(r0 === 0)) {
      r1 = heapClassInst.heap32[fp];
      if (uint(r0) > uint(numDefine31)) {
        r2 = r0 >>> 1;
        r2 = r0 | r2;
        r3 = r2 >>> numDefine2;
        r2 = r2 | r3;
        r3 = r2 >>> numDefine4;
        r2 = r2 | r3;
        r3 = r2 >>> numDefine8;
        r2 = r2 | r3;
        r3 = r2 >>> numDefine16;
        r2 = r2 | r3;
        r3 = r2 ^ -1;
        r4 = numDefine55765;
        r3 = r3 >>> 1;
        r2 = r4 & ~r2;
        r3 = r3 & numDefine55765;
        r2 = (r2 + r3) | 0;
        r3 = r2 >>> numDefine2;
        r2 = r2 & numDefine93459;
        r3 = r3 & numDefine93459;
        r2 = (r2 + r3) | 0;
        r3 = r2 >>> numDefine4;
        r2 = r2 & numDefine45135;
        r3 = r3 & numDefine45135;
        r2 = (r2 + r3) | 0;
        r3 = r2 >>> numDefine8;
        r2 = r2 & numDefine11935;
        r3 = r3 & numDefine11935;
        r2 = (r2 + r3) | 0;
        r3 = r2 & numDefine65535;
        r2 = r2 >>> numDefine16;
        r5 = numDefine26;
        r2 = (r3 + r2) | 0;
        r3 = 1;
        r2 = (r5 - r2) | 0;
        r2 = r3 << r2;
        r0 = (r0 + r2) | 0;
        r0 = (r0 + -1) | 0;
        if (uint(r0) > uint(numDefine255)) {
          r2 = r0 >>> 1;
          r2 = r0 | r2;
          r3 = r2 >>> numDefine2;
          r2 = r2 | r3;
          r3 = r2 >>> numDefine4;
          r2 = r2 | r3;
          r3 = r2 >>> numDefine8;
          r2 = r2 | r3;
          r3 = r2 >>> numDefine16;
          r2 = r2 | r3;
          r3 = r2 ^ -1;
          r3 = r3 >>> 1;
          r4 = r4 & ~r2;
          r2 = r3 & numDefine55765;
          r4 = (r4 + r2) | 0;
          r2 = r4 >>> numDefine2;
          r4 = r4 & numDefine93459;
          r2 = r2 & numDefine93459;
          r4 = (r4 + r2) | 0;
          r2 = r4 >>> numDefine4;
          r4 = r4 & numDefine45135;
          r2 = r2 & numDefine45135;
          r4 = (r4 + r2) | 0;
          r2 = r4 >>> numDefine8;
          r4 = r4 & numDefine11935;
          r2 = r2 & numDefine11935;
          r4 = (r4 + r2) | 0;
          r2 = r4 & numDefine65535;
          r4 = r4 >>> numDefine16;
          r4 = (r2 + r4) | 0;
          r2 = (r5 - r4) | 0;
          r0 = r0 >>> r2;
          r2 = numDefine24;
          r0 = r0 ^ numDefine32;
          r4 = (r2 - r4) | 0;
          label = numDefine5;
        } else {
          label = numDefine3;
        }
      } else {
        label = numDefine3;
      }
      if (label === numDefine3) {
        r0 = r0 >>> numDefine3;
        r4 = 0;
      }
      r2 = r4 << numDefine2;
      r2 = (r1 + r2) | 0;
      r2 = r2 >> numDefine2;
      r3 = -1;
      r2 = heapClassInst.heap32[r2 + 1];
      r0 = r3 << r0;
      r0 = r2 & r0;
      if (r0 === 0) {
        r0 = r1 >> numDefine2;
        r4 = (r4 + 1) | 0;
        r0 = heapClassInst.heap32[r0];
        r4 = r3 << r4;
        r0 = r0 & r4;
        if (r0 === 0) {
          break repeat1;
        } else {
          r4 = (r0 + -1) | 0;
          r0 = r4 & ~r0;
          r4 = r0 >>> 1;
          r0 = r0 & numDefine55765;
          r4 = r4 & numDefine55765;
          r0 = (r0 + r4) | 0;
          r4 = r0 >>> numDefine2;
          r0 = r0 & numDefine93459;
          r4 = r4 & numDefine93459;
          r0 = (r0 + r4) | 0;
          r4 = r0 >>> numDefine4;
          r0 = r0 & numDefine45135;
          r4 = r4 & numDefine45135;
          r0 = (r0 + r4) | 0;
          r4 = r0 >>> numDefine8;
          r0 = r0 & numDefine11935;
          r4 = r4 & numDefine11935;
          r0 = (r0 + r4) | 0;
          r4 = r0 & numDefine65535;
          r0 = r0 >>> numDefine16;
          r4 = (r4 + r0) | 0;
          r0 = r4 << numDefine2;
          r0 = (r1 + r0) | 0;
          r0 = r0 >> numDefine2;
          r0 = heapClassInst.heap32[r0 + 1];
        }
      }
      r2 = (r0 + -1) | 0;
      r2 = r2 & ~r0;
      r5 = r2 >>> 1;
      r2 = r2 & numDefine55765;
      r5 = r5 & numDefine55765;
      r2 = (r2 + r5) | 0;
      r5 = r2 >>> numDefine2;
      r2 = r2 & numDefine93459;
      r5 = r5 & numDefine93459;
      r2 = (r2 + r5) | 0;
      r5 = r2 >>> numDefine4;
      r2 = r2 & numDefine45135;
      r5 = r5 & numDefine45135;
      r2 = (r2 + r5) | 0;
      r5 = r2 >>> numDefine8;
      r2 = r2 & numDefine11935;
      r5 = r5 & numDefine11935;
      r2 = (r2 + r5) | 0;
      r5 = r2 & numDefine65535;
      r2 = r2 >>> numDefine16;
      r2 = (r5 + r2) | 0;
      r0 = r0 === 0 ? r3 : r2;
      r2 = r4 << numDefine7;
      r2 = (r1 + r2) | 0;
      r3 = r0 << numDefine2;
      r2 = (r2 + r3) | 0;
      r3 = r2 >> numDefine2;
      r3 = heapClassInst.heap32[r3 + numDefine24];
      if (!(r3 === 0)) {
        r2 = (r2 + numDefine96) | 0;
        r5 = r3 >> numDefine2;
        r6 = heapClassInst.heap32[r5 + numDefine2];
        r5 = heapClassInst.heap32[r5 + numDefine3];
        r7 = r6 >> numDefine2;
        r8 = r5 >> numDefine2;
        heapClassInst.heap32[r7 + numDefine3] = r5;
        r2 = r2 >> numDefine2;
        heapClassInst.heap32[r8 + numDefine2] = r6;
        r5 = heapClassInst.heap32[r2];
        if (!(r5 !== r3)) {
          r5 = blockNull;
          heapClassInst.heap32[r2] = r6;
          if (!(r6 !== r5)) {
            r2 = r4 << numDefine2;
            r2 = (r1 + r2) | 0;
            r2 = r2 >> numDefine2;
            r5 = 1;
            r0 = r5 << r0;
            r6 = heapClassInst.heap32[r2 + 1];
            r0 = r6 & ~r0;
            heapClassInst.heap32[r2 + 1] = r0;
            if (!(r0 !== 0)) {
              r0 = r1 >> numDefine2;
              r1 = r5 << r4;
              r2 = heapClassInst.heap32[r0];
              r1 = r2 & ~r1;
              heapClassInst.heap32[r0] = r1;
            }
          }
        }
        commonVariable.rg0 = r3;
        return;
      }
    }
  } while (false);
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function blockPrepareUsed(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  if (r0 === 0) {
    r0 = 0;
    commonVariable.rg0 = r0;
    return;
  } else {
    r1 = heapClassInst.heap32[fp + numDefine2];
    r2 = r0 >> numDefine2;
    r3 = heapClassInst.heap32[r2 + 1];
    r4 = r3 & numDefineNeg4;
    r5 = (r1 + numDefine16) | 0;
    if (uint(r4) >= uint(r5)) {
      r3 = heapClassInst.heap32[fp];
      r5 = (r0 + numDefine8) | 0;
      r6 = (r5 + r1) | 0;
      r7 = r6 >> numDefine2;
      r8 = numDefineNeg4;
      r9 = heapClassInst.heap32[r7];
      r8 = (r8 - r1) | 0;
      r9 = r9 & numDefine3;
      r4 = (r8 + r4) | 0;
      r4 = r9 | r4;
      heapClassInst.heap32[r7] = r4;
      r4 = heapClassInst.heap32[r2 + 1];
      r4 = r4 & numDefine3;
      r4 = r4 | r1;
      heapClassInst.heap32[r2 + 1] = r4;
      r4 = heapClassInst.heap32[r7];
      r4 = (r4 + numDefineNeg4) | 0;
      r8 = (r1 + numDefine4) | 0;
      r4 = r4 & numDefineNeg4;
      r1 = (r1 + numDefine8) | 0;
      r9 = (r4 + r8) | 0;
      r4 = (r4 + r1) | 0;
      r9 = (r5 + r9) | 0;
      r4 = (r5 + r4) | 0;
      r6 = (r6 + numDefineNeg4) | 0;
      r9 = r9 >> numDefine2;
      r4 = r4 >> numDefine2;
      heapClassInst.heap32[r9] = r6;
      r9 = heapClassInst.heap32[r4];
      r9 = r9 | numDefine2;
      heapClassInst.heap32[r4] = r9;
      r4 = heapClassInst.heap32[r7];
      r4 = r4 | 1;
      heapClassInst.heap32[r7] = r4;
      r4 = heapClassInst.heap32[r2 + 1];
      r4 = (r4 + numDefineNeg4) | 0;
      r4 = r4 & numDefineNeg4;
      r4 = (r5 + r4) | 0;
      r4 = r4 >> numDefine2;
      heapClassInst.heap32[r4] = r0;
      r4 = heapClassInst.heap32[r7];
      r9 = r4 & numDefineNeg4;
      r10 = r4 | numDefine2;
      heapClassInst.heap32[r7] = r10;
      if (uint(r9) > uint(numDefine255)) {
        r4 = r9 >>> 1;
        r4 = r9 | r4;
        r7 = r4 >>> numDefine2;
        r4 = r4 | r7;
        r7 = r4 >>> numDefine4;
        r4 = r4 | r7;
        r7 = r4 >>> numDefine8;
        r4 = r4 | r7;
        r7 = r4 >>> numDefine16;
        r4 = r4 | r7;
        r7 = r4 ^ -1;
        r10 = numDefine55765;
        r7 = r7 >>> 1;
        r4 = r10 & ~r4;
        r7 = r7 & numDefine55765;
        r4 = (r4 + r7) | 0;
        r7 = r4 >>> numDefine2;
        r4 = r4 & numDefine93459;
        r7 = r7 & numDefine93459;
        r4 = (r4 + r7) | 0;
        r7 = r4 >>> numDefine4;
        r4 = r4 & numDefine45135;
        r7 = r7 & numDefine45135;
        r4 = (r4 + r7) | 0;
        r7 = r4 >>> numDefine8;
        r4 = r4 & numDefine11935;
        r7 = r7 & numDefine11935;
        r4 = (r4 + r7) | 0;
        r7 = r4 & numDefine65535;
        r4 = r4 >>> numDefine16;
        r10 = numDefine26;
        r4 = (r7 + r4) | 0;
        r7 = (r10 - r4) | 0;
        r9 = r9 >>> r7;
        r7 = numDefine24;
        r9 = r9 ^ numDefine32;
        r4 = (r7 - r4) | 0;
      } else {
        r9 = r4 >>> numDefine3;
        r4 = 0;
      }
      r7 = r4 << numDefine7;
      r7 = (r3 + r7) | 0;
      r10 = r9 << numDefine2;
      r7 = (r7 + r10) | 0;
      r7 = r7 >> numDefine2;
      r8 = (r5 + r8) | 0;
      r1 = (r5 + r1) | 0;
      r5 = heapClassInst.heap32[r7 + numDefine24];
      r8 = r8 >> numDefine2;
      r1 = r1 >> numDefine2;
      r10 = blockNull;
      heapClassInst.heap32[r8] = r5;
      r5 = r5 >> numDefine2;
      heapClassInst.heap32[r1] = r10;
      heapClassInst.heap32[r5 + numDefine3] = r6;
      r1 = 1;
      r5 = r3 >> numDefine2;
      heapClassInst.heap32[r7 + numDefine24] = r6;
      r6 = r4 << numDefine2;
      r4 = r1 << r4;
      r7 = heapClassInst.heap32[r5];
      r3 = (r3 + r6) | 0;
      r4 = r7 | r4;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r5] = r4;
      r1 = r1 << r9;
      r4 = heapClassInst.heap32[r3 + 1];
      r1 = r4 | r1;
      heapClassInst.heap32[r3 + 1] = r1;
      r3 = heapClassInst.heap32[r2 + 1];
    }
    r1 = r3 & numDefineNeg4;
    r0 = (r0 + numDefine8) | 0;
    r1 = (r0 + r1) | 0;
    r1 = r1 >> numDefine2;
    r3 = heapClassInst.heap32[r1];
    r3 = r3 & numDefineNeg3;
    heapClassInst.heap32[r1] = r3;
    r1 = heapClassInst.heap32[r2 + 1];
    r1 = r1 & numDefineNeg2;
    heapClassInst.heap32[r2 + 1] = r1;
    commonVariable.rg0 = r0;
    return;
  }
}

function assert(condition: boolean, text: string = ''): void {
  if (!condition) {
    let errorMessage = 'Assertion failed: ' + text;
  }
}

function mallocInt(bytes: number): number {
  if (heapClassInst.heap === null) {
  }
  let newOffset = commonVariable.heapNewPos;
  commonVariable.heapNewPos += (bytes + numDefine3) & numDefine0xfffffffc;

  if (commonVariable.heapNewPos > mandreelTotalMemory) {
    assert(false);
  }
  return newOffset;
}

function strcpy(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = r1 ^ r0;
  r2 = r2 & numDefine3;
  repeat1: do {
    if (r2 === 0) {
      r2 = r0 & numDefine3;
      if (r2 !== 0) {
        r2 = r0 | numDefineNeg4;
        repeat5: while (true) {
          if (r2 !== 0) {
            r3 = heapClassInst.heapU8[r1];
            r4 = (r0 + 1) | 0;
            r1 = (r1 + 1) | 0;
            r2 = (r2 + 1) | 0;
            heapClassInst.heap8[r0] = r3;
            r0 = r4;
            if (!(r3 !== 0)) {
              break repeat1;
            }
          } else {
            break repeat5;
          }
        }
      }
      r2 = r1 >> numDefine2;
      r2 = heapClassInst.heap32[r2];
      r3 = r2 & numDefineNeg62144;
      r3 = r3 ^ numDefineNeg62144;
      r4 = (r2 + numDefineNeg43009) | 0;
      r3 = r3 & r4;
      repeat9: do {
        if (r3 === 0) {
          r1 = (r1 + numDefine4) | 0;
          while (true) {
            r3 = r0 >> numDefine2;
            r4 = r1 >> numDefine2;
            heapClassInst.heap32[r3] = r2;
            r2 = heapClassInst.heap32[r4];
            r3 = r2 & numDefineNeg62144;
            r0 = (r0 + numDefine4) | 0;
            r1 = (r1 + numDefine4) | 0;
            r3 = r3 ^ numDefineNeg62144;
            r4 = (r2 + numDefineNeg43009) | 0;
            r3 = r3 & r4;
            if (!(r3 === 0)) {
              break repeat9;
            }
          }
        }
      } while (false);
      r1 = r2 & numDefine255;
      heapClassInst.heap8[r0] = r2;
      if (!(r1 === 0)) {
        r0 = (r0 + 1) | 0;
        repeat15: while (true) {
          r2 = r2 >>> numDefine8;
          r1 = (r0 + 1) | 0;
          heapClassInst.heap8[r0] = r2;
          r3 = r2 & numDefine255;
          r0 = r1;
          if (r3 === 0) {
            break repeat1;
          } else {
            continue repeat15;
          }
        }
      }
    } else {
      repeat17: while (true) {
        r2 = heapClassInst.heapU8[r1];
        r3 = (r0 + 1) | 0;
        r1 = (r1 + 1) | 0;
        heapClassInst.heap8[r0] = r2;
        r0 = r3;
        if (r2 === 0) {
          break repeat1;
        } else {
          continue repeat17;
        }
      }
    }
  } while (false);
  return;
}

function mallocNew(sp: number): void {
  sp = sp;
  let size = heapClassInst.heapU32[sp >> numDefine2];

  if (size === 0) {
    size = numDefine4;
  }

  if (tlsfPtr.tlsfPtr === 0) {
    let addr = mallocInt(mandreelHeapMemory);

    sp -= numDefine8;
    heapClassInst.heap32[sp >> numDefine2] = addr;
    heapClassInst.heap32[(sp + numDefine4) >> numDefine2] = mandreelHeapMemory;
    tlsfCreate(sp);
    tlsfPtr.tlsfPtr = commonVariable.rg0;
  }

  sp -= numDefine8;

  heapClassInst.heap32[sp >> numDefine2] = tlsfPtr.tlsfPtr;
  heapClassInst.heap32[(sp + numDefine4) >> numDefine2] = size;
  tlsfMalloc(sp);

  if (commonVariable.rg0 === 0) {
    dump('mallocNew failed ' + size + '\n');
    assert(false);
  }
}

function myArgTest(sp: number): void {
  let ptr = heapClassInst.heapU32[sp >> numDefine2];
  let size = heapClassInst.heapU32[(sp + numDefine4) >> numDefine2];

  let arg = heapClassInst.heapU32[ptr >> numDefine2];

  if (size === numDefine4) {
    heapClassInst.heap32[ptr >> numDefine2] = arg + numDefine4;

    arg = heapClassInst.heap32[arg >> numDefine2];

    heapClassInst.heap32[argTestLocal >> numDefine2] = arg;
  } else {
    arg = (arg + numDefine7) & ~7;

    heapClassInst.heap32[ptr >> numDefine2] = arg + numDefine8;

    let value0 = heapClassInst.heap32[arg >> numDefine2];
    let value1 = heapClassInst.heap32[(arg + numDefine4) >> numDefine2];

    heapClassInst.heap32[argTestLocal >> numDefine2] = value0;
    heapClassInst.heap32[(argTestLocal + numDefine4) >> numDefine2] = value1;
  }
  commonVariable.rg0 = argTestLocal;
}

function llvmReadDouble(addr: number): number {
  let val0 = heapClassInst.heap32[addr >> numDefine2];
  let val1 = heapClassInst.heap32[(addr + numDefine4) >> numDefine2];

  heapClassInst.heap32[llvmDoubleAddr >> numDefine2] = val0;
  heapClassInst.heap32[(llvmDoubleAddr + numDefine4) >> numDefine2] = val1;

  let result = heapClassInst.heapDouble[llvmDoubleAddr >> numDefine3];

  return Number(result);
}

function llvmMoveDouble(addrDst: number, addrSrc: number): void {
  let val0 = heapClassInst.heapU32[addrSrc >> numDefine2];
  let val1 = heapClassInst.heapU32[(addrSrc + numDefine4) >> numDefine2];

  heapClassInst.heapU32[addrDst >> numDefine2] = val0;
  heapClassInst.heapU32[(addrDst + numDefine4) >> numDefine2] = val1;
}

function dtostr(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg40;
  let g0 = i7 >> numDefine2;
  f0 = llvmReadDouble(sp);
  r0 = sp + numDefineNeg8;
  llvmWriteDouble(sp + numDefineNeg8, f0);
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + 1];
  r1 = heapClassInst.heap32[fp + numDefine2];
  r2 = heapClassInst.heap32[fp + numDefine3];
  r3 = heapClassInst.heap32[fp + numDefine4];
  r4 = heapClassInst.heap32[fp + numDefine5];
  r5 = heapClassInst.heap32[fp + numDefine6];
  r6 = heapClassInst.heap32[fp + numDefineNeg2];
  if (r0 > numDefine35071) {
    r7 = r0 ^ numDefine59360;
    r7 = r6 | r7;
    if (r7 === 0) {
      label = numDefine13;
    } else {
      r7 = r0 ^ numDefine35072;
      r6 = r6 | r7;
      if (r6 !== 0) {
        label = numDefine20;
      } else {
        label = numDefine5;
      }
    }
  } else {
    r7 = r0 ^ numDefineNeg48576;
    r7 = r6 | r7;
    if (r7 === 0) {
      label = numDefine5;
    } else {
      r7 = r0 ^ numDefineNeg24288;
      r6 = r6 | r7;
      if (r6 === 0) {
        label = numDefine13;
      } else {
        label = numDefine20;
      }
    }
  }
  repeat6: do {
    switch (label) {
      case numDefine13:
        if (r2 > 0) {
          r0 = (r2 + -1) | 0;
          r3 = numDefine2;
          r4 = 0;
          r5 = (r2 + numDefine2) | 0;
          r0 = uint(r0) > uint(r3) ? r0 : r3;
          r3 = (r4 - r2) | 0;
          r0 = (r5 - r0) | 0;
          r4 = twoEStr9655;
          r5 = r1;
          repeat10: while (true) {
            r6 = heapClassInst.heapU8[r4];
            r0 = (r0 + -1) | 0;
            r7 = (r5 + 1) | 0;
            r4 = (r4 + 1) | 0;
            heapClassInst.heap8[r5] = r6;
            r5 = r7;
            if (!(r0 !== 0)) {
              break repeat10;
            }
          }
          r0 = numDefineNeg3;
          r4 = numDefine3;
          r0 = uint(r3) > uint(r0) ? r2 : r4;
        } else {
          r0 = 0;
        }
        if (r0 >= r2) {
          commonVariable.rg0 = r0;
          return;
        } else {
          label = numDefine11;
          break repeat6;
        }
      case numDefine20:
        f1 = 0;
        if (f0 !== f1) {
          r0 = r0 >>> numDefine20;
          r0 = r0 & numDefine2047;
          r0 = (r0 + numDefineNeg1023) | 0;
          f2 = r0;
          f3 = numDefineFloat312;
          f2 = f2 * f3;
          r0 = f2 | 0;
          r6 = (r0 + 1) | 0;
          if (f0 < f1) {
            f1 = -f0;
            r2 = (r2 + -1) | 0;
            r7 = (r1 + 1) | 0;
            r8 = numDefine45;
            heapClassInst.heap8[r1] = r8;
          } else {
            r7 = r1;
            f1 = f0;
          }
          repeat23: do {
            if (r4 === 0) {
              f2 = numDefineFloat05;
            } else {
              f2 = numDefineFloat05;
              r8 = r4;
              f3 = numDefineFloat101;
              while (true) {
                r8 = (r8 + -1) | 0;
                f2 = f2 * f3;
                if (!(r8 !== 0)) {
                  break repeat23;
                }
              }
            }
          } while (false);
          f1 = f1 + f2;
          f2 = 1;
          if (f1 < f2) {
            r2 = (r2 + -1) | 0;
            r8 = (r7 + 1) | 0;
            r9 = numDefine48;
            heapClassInst.heap8[r7] = r9;
            r7 = r8;
          }
          repeat32: do {
            if (r6 > 0) {
              repeat34: do {
                if (uint(r6) > uint(numDefine10)) {
                  r0 = (r0 + 1) | 0;
                  f2 = numDefine10;
                  f3 = numDefineN10;
                  while (true) {
                    r0 = (r0 + numDefineNeg10) | 0;
                    f2 = f2 * f3;
                    if (!(uint(r0) > uint(numDefine10))) {
                      break repeat34;
                    }
                  }
                } else {
                  f2 = numDefine10;
                  r0 = r6;
                }
              } while (false);
              if (uint(r0) > uint(1)) {
                r0 = (r0 + -1) | 0;
                f3 = numDefine10;
                repeat42: while (true) {
                  r0 = (r0 + -1) | 0;
                  f2 = f2 * f3;
                  if (!(r0 !== 0)) {
                    break repeat42;
                  }
                }
                r0 = 1;
              } else {
                r0 = 1;
              }
              repeat46: while (true) {
                f3 = numDefineFloat902;
                if (f2 > f3) {
                  f3 = f1 / f2;
                  r8 = f3 | 0;
                  if (r0 === 0) {
                    label = numDefine52;
                  } else {
                    r9 = r8 & numDefine255;
                    if (r9 !== 0) {
                      label = numDefine52;
                    } else {
                      label = numDefine64;
                    }
                  }
                  if (label === numDefine52) {
                    r0 = (r8 + numDefine48) | 0;
                    heapClassInst.heap8[r7] = r0;
                    if (r2 !== 0) {
                      r0 = r8 << numDefine24;
                      r0 = r0 >> numDefine24;
                      f3 = r0;
                      f3 = f3 * f2;
                      r7 = (r7 + 1) | 0;
                      f1 = f1 - f3;
                      r2 = (r2 + -1) | 0;
                      r0 = 0;
                    } else {
                      break repeat46;
                    }
                  }
                  f3 = numDefine10;
                  f2 = f2 / f3;
                } else {
                  label = numDefine66;
                  break repeat32;
                }
              }
              f0 = f0 / f2;
              llvmWriteDouble(i7, f0);
              heapClassInst.heap32[g0 + numDefine2] = r1;
              heapClassInst.heap32[g0 + numDefine3] = r2;
              heapClassInst.heap32[g0 + numDefine4] = r3;
              heapClassInst.heap32[g0 + numDefine5] = r4;
              heapClassInst.heap32[g0 + numDefine6] = 0;
              dtostr(i7);
              r0 = commonVariable.rg0;
              if (r0 === 0) {
                label = numDefine83;
              } else {
                r3 = (r0 + r7) | 0;
                r7 = (r3 + 1) | 0;
                if (r2 !== r0) {
                  r3 = (r3 + numDefine2) | 0;
                  r4 = numDefine101;
                  heapClassInst.heap8[r7] = r4;
                  r7 = r3;
                }
                r2 = (r2 + -1) | 0;
                r3 = (r2 - r0) | 0;
                repeat60: do {
                  if (r6 < numDefine1000) {
                    if (r6 < numDefine100) {
                      if (r6 > numDefine9) {
                        label = numDefine90;
                        break repeat60;
                      } else {
                        label = numDefine91;
                        break repeat60;
                      }
                    } else {
                      label = numDefine87;
                      break repeat60;
                    }
                  } else {
                    if (r2 !== r0) {
                      r0 = (r6 / numDefine1000) | 0;
                      r2 = (r7 + 1) | 0;
                      r0 = (r0 + numDefine48) | 0;
                      heapClassInst.heap8[r7] = r0;
                      r7 = r2;
                    }
                    r3 = (r3 + -1) | 0;
                    r6 = r6 % numDefine1000 | 0;
                    label = numDefine87;
                  }
                } while (false);
                if (label === numDefine87) {
                  if (r3 !== 0) {
                    r0 = (r6 / numDefine100) | 0;
                    r2 = (r7 + 1) | 0;
                    r0 = (r0 + numDefine48) | 0;
                    heapClassInst.heap8[r7] = r0;
                    r7 = r2;
                  }
                  r3 = (r3 + -1) | 0;
                  r6 = r6 % numDefine100 | 0;
                  label = numDefine90;
                }
                if (label === numDefine90) {
                  if (r3 !== 0) {
                    r0 = (r6 / numDefine10) | 0;
                    r2 = (r7 + 1) | 0;
                    r0 = (r0 + numDefine48) | 0;
                    heapClassInst.heap8[r7] = r0;
                    r7 = r2;
                  }
                  r3 = (r3 + -1) | 0;
                  r6 = r6 % numDefine10 | 0;
                }
                if (r3 !== 0) {
                  r0 = (r6 + numDefine48) | 0;
                  heapClassInst.heap8[r7] = r0;
                  if (r3 === 1) {
                    label = numDefine83;
                  } else {
                    r7 = (r7 + 1) | 0;
                    label = numDefine82;
                  }
                } else {
                  label = numDefine82;
                }
              }
            } else {
              f2 = numDefineFloat101;
              label = numDefine66;
            }
          } while (false);
          repeat81: do {
            if (label === numDefine66) {
              if (r7 === r1) {
                if (r2 === 0) {
                  label = numDefine83;
                  break repeat81;
                } else {
                  r2 = (r2 + -1) | 0;
                  r6 = (r7 + 1) | 0;
                  r0 = numDefine48;
                  heapClassInst.heap8[r7] = r0;
                  r7 = r6;
                }
              }
              if (!(r4 !== 0)) {
                r6 = 1;
                r6 = (r6 - r1) | 0;
                r6 = (r6 + r7) | 0;
                if (!(uint(r6) < uint(r3))) {
                  label = numDefine82;
                  break repeat81;
                }
              }
              if (r2 === 0) {
                label = numDefine83;
              } else {
                r6 = (r2 + -1) | 0;
                r0 = (r7 + 1) | 0;
                r2 = numDefine46;
                heapClassInst.heap8[r7] = r2;
                if (r5 === 0) {
                  if (!(r4 !== 0)) {
                    r3 = (r1 + r3) | 0;
                    r3 = (r3 + 1) | 0;
                    r4 = (r3 - r0) | 0;
                  }
                } else {
                  r3 = r4 === 0 ? r3 : r4;
                  r3 = (r1 + r3) | 0;
                  r3 = (r3 + 1) | 0;
                  r4 = (r3 - r0) | 0;
                }
                if (uint(r4) > uint(r6)) {
                  label = numDefine83;
                } else {
                  if (r4 !== 0) {
                    r3 = (r4 + 1) | 0;
                    r6 = (r7 + 1) | 0;
                    f3 = numDefine10;
                    repeat99: while (true) {
                      f0 = f1 / f2;
                      r0 = f0 | 0;
                      r2 = r0 << numDefine24;
                      r2 = r2 >> numDefine24;
                      f0 = r2;
                      f0 = f0 * f2;
                      r4 = (r4 + -1) | 0;
                      f2 = f2 / f3;
                      f1 = f1 - f0;
                      r2 = (r6 + 1) | 0;
                      r0 = (r0 + numDefine48) | 0;
                      heapClassInst.heap8[r6] = r0;
                      r6 = r2;
                      if (!(r4 !== 0)) {
                        break repeat99;
                      }
                    }
                    r7 = (r7 + r3) | 0;
                    label = numDefine82;
                  } else {
                    r7 = r0;
                    label = numDefine82;
                  }
                }
              }
            }
          } while (false);
          switch (label) {
            case numDefine83:
              r1 = 0;
              commonVariable.rg0 = r1;
              return;
            case numDefine82:
              r3 = 0;
              heapClassInst.heap8[r7] = r3;
              r1 = (r7 - r1) | 0;
              commonVariable.rg0 = r1;
              return;
            default:
              break;
          }
        } else {
          r3 = 1;
          r5 = (r4 + numDefine2) | 0;
          r4 = r4 === 0 ? r3 : r5;
          r5 = numDefine8;
          r2 = uint(r4) > uint(r2) ? r5 : r4;
          if (r2 === 0) {
            label = numDefine23;
          } else {
            if (r0 < 0) {
              r0 = numDefine45;
              heapClassInst.heap8[r1] = r0;
              r0 = r3;
              label = numDefine25;
            } else {
              label = numDefine23;
            }
          }
          if (label === numDefine23) {
            r0 = 0;
          }
          if (uint(r0) < uint(r2)) {
            r5 = numDefine48;
            repeat115: while (true) {
              r4 = (r0 + 1) | 0;
              heapClassInst.heap8[r1 + r0] = r5;
              r0 = r4;
              if (!(r2 !== r4)) {
                break repeat115;
              }
            }
            r0 = r2;
          }
          r2 = numDefine2;
          r4 = heapClassInst.heapU8[r1];
          r2 = r4 === numDefine48 ? r3 : r2;
          r3 = numDefine46;
          r4 = 0;
          heapClassInst.heap8[r1 + r2] = r3;
          heapClassInst.heap8[r1 + r0] = r4;
          commonVariable.rg0 = r0;
          return;
        }
        break;
      case numDefine5:
        if (r2 > 0) {
          r0 = (r2 + -1) | 0;
          r3 = numDefine2;
          r4 = 0;
          r5 = (r2 + numDefine2) | 0;
          r0 = uint(r0) > uint(r3) ? r0 : r3;
          r3 = (r4 - r2) | 0;
          r0 = (r5 - r0) | 0;
          r4 = twoEStr7654;
          r5 = r1;
          repeat122: while (true) {
            r6 = heapClassInst.heapU8[r4];
            r0 = (r0 + -1) | 0;
            r7 = (r5 + 1) | 0;
            r4 = (r4 + 1) | 0;
            heapClassInst.heap8[r5] = r6;
            r5 = r7;
            if (!(r0 !== 0)) {
              break repeat122;
            }
          }
          r0 = numDefineNeg3;
          r4 = numDefine3;
          r0 = uint(r3) > uint(r0) ? r2 : r4;
        } else {
          r0 = 0;
        }
        if (r0 >= r2) {
          label = numDefine12;
        } else {
          label = numDefine11;
        }
      default:
        break;
    }
  } while (false);
  if (label === numDefine11) {
    r2 = 0;
    heapClassInst.heap8[r1 + r0] = r2;
    r0 = (r0 + 1) | 0;
  }
  commonVariable.rg0 = r0;
  return;
}

function swrite(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine2];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0 + 1];
  r2 = heapClassInst.heap32[r0 + numDefine2];
  r3 = heapClassInst.heap32[fp + 1];
  if (!(r2 === r1)) {
    r2 = (r2 - r1) | 0;
    r4 = heapClassInst.heap32[r0];
    r2 = uint(r2) < uint(r3) ? r2 : r3;
    if (r4 !== 0) {
      r5 = heapClassInst.heap32[fp];
      r1 = (r4 + r1) | 0;
      heapClassInst.heap32[g0] = r1;
      heapClassInst.heap32[g0 + 1] = r5;
      heapClassInst.heap32[g0 + numDefine2] = r2;
      memcpy(i7);
      r1 = heapClassInst.heap32[r0 + 1];
      r4 = heapClassInst.heap32[r0];
      r1 = (r1 + r2) | 0;
      r5 = 0;
      heapClassInst.heap8[r4 + r1] = r5;
      r1 = heapClassInst.heap32[r0 + 1];
    }
    r1 = (r1 + r2) | 0;
    heapClassInst.heap32[r0 + 1] = r1;
  }
  commonVariable.rg0 = r3;
  return;
}

function registerDelegate(ptrFunc: (number: number) => void): number {
  let funcId = mandreelPosFunctionTable;
  functionTable.push(ptrFunc);

  mandreelPosFunctionTable += 1;
  // deBugLog('funcId :' + funcId * numDefine4);
  return funcId * numDefine4;
}

function mandreelGetlocalstorage(): GetItemArr | null {
  return mandreelWindow.localStorage;
}

function sinf(sp: number): void {
  let value = heapClassInst.heapFloat[sp >> numDefine2];
  commonVariable.fg0 = Math.sin(value);
}

function sqrtf(sp: number): void {
  let value = heapClassInst.heapFloat[sp >> numDefine2];
  commonVariable.fg0 = Math.sqrt(value);
}

function assertNew(sp: number): void {
  sp = sp;
  let p0 = heapClassInst.heap32[sp >> numDefine2];
  sp += numDefine4;
  let p1 = heapClassInst.heap32[sp >> numDefine2];
  sp += numDefine4;
  let line = heapClassInst.heap32[sp >> numDefine2];
  sp += numDefine4;
  let name = getStringFromPtr(p0);
  let file = getStringFromPtr(p1);
  assert(false, name + file + ' ' + String(line));
}

function znwj(sp: number): void {
  mallocNew(sp);
}

function zdlPv(sp: number): void {
  free(sp);
}

function pause(milliseconds: number): void {}

function acosf(sp: number): void {
  let value = heapClassInst.heapFloat[sp >> numDefine2];
  commonVariable.fg0 = Math.acos(value);
}

function atan2f(sp: number): void {
  sp = sp;
  let x = heapClassInst.heapFloat[sp >> numDefine2];
  sp += numDefine4;
  let y = heapClassInst.heapFloat[sp >> numDefine2];
  commonVariable.fg0 = Math.atan2(x, y);
}

function zn20btAlignedObjectArrayI16btBroadphasePairE17quickSortInternalI29btBroadphasePairSortPredicateEEvTIi(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let r16: number = 0;
  let r17: number = 0;
  let r18: number = 0;
  let r19: number = 0;
  let r20: number = 0;
  let r21: number = 0;
  let r22: number = 0;
  let r23: number = 0;
  let r24: number = 0;
  let r25: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine2];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = (r0 + r1) | 0;
  r3 = r2 >>> numDefine31;
  r4 = heapClassInst.heap32[fp];
  r2 = (r2 + r3) | 0;
  r3 = r4 >> numDefine2;
  r2 = r2 & numDefine70910;
  r5 = heapClassInst.heap32[r3 + numDefine3];
  r2 = r2 << numDefine3;
  r2 = (r5 + r2) | 0;
  r2 = r2 >> numDefine2;
  r5 = heapClassInst.heap32[r2];
  r6 = heapClassInst.heap32[r2 + 1];
  r2 = heapClassInst.heap32[r2 + numDefine2];
  r7 = r1;
  r8 = r0;
  repeat1: while (true) {
    r9 = heapClassInst.heap32[r3 + numDefine3];
    r10 = r7 << numDefine4;
    r10 = (r9 + r10) | 0;
    r11 = 0;
    repeat3: while (true) {
      r12 = r11 << numDefine4;
      r12 = (r10 + r12) | 0;
      r12 = r12 >> numDefine2;
      r13 = r11 << numDefine2;
      r14 = heapClassInst.heap32[r12];
      if (r14 !== 0) {
        r15 = r14 >> numDefine2;
        r15 = heapClassInst.heap32[r15 + numDefine3];
      } else {
        r15 = -1;
      }
      if (r5 !== 0) {
        r16 = r5 >> numDefine2;
        r16 = heapClassInst.heap32[r16 + numDefine3];
      } else {
        r16 = -1;
      }
      r17 = r13 << numDefine2;
      r17 = (r10 + r17) | 0;
      r17 = r17 >> numDefine2;
      r17 = heapClassInst.heap32[r17 + 1];
      if (r17 !== 0) {
        r18 = r17 >> numDefine2;
        r18 = heapClassInst.heap32[r18 + numDefine3];
      } else {
        r18 = -1;
      }
      if (r6 !== 0) {
        r19 = r6 >> numDefine2;
        r19 = heapClassInst.heap32[r19 + numDefine3];
      } else {
        r19 = -1;
      }
      repeat21: do {
        if (!(r15 > r16)) {
          if (!(r14 !== r5)) {
            if (r18 > r19) {
              break repeat21;
            }
          }
          if (r14 !== r5) {
            break repeat3;
          } else {
            if (r17 !== r6) {
              break repeat3;
            } else {
              r15 = r13 << numDefine2;
              r15 = (r10 + r15) | 0;
              r15 = r15 >> numDefine2;
              r15 = heapClassInst.heap32[r15 + numDefine2];
              if (!(uint(r15) > uint(r2))) {
                break repeat3;
              }
            }
          }
        }
      } while (false);
      r11 = (r11 + 1) | 0;
      continue repeat3;
    }
    r18 = r8 << numDefine4;
    r15 = (r7 + r11) | 0;
    r9 = (r9 + r18) | 0;
    r16 = 0;
    repeat30: while (true) {
      r19 = r16 << numDefine2;
      if (r5 !== 0) {
        r20 = r5 >> numDefine2;
        r20 = heapClassInst.heap32[r20 + numDefine3];
      } else {
        r20 = -1;
      }
      r21 = r19 << numDefine2;
      r21 = (r9 + r21) | 0;
      r21 = r21 >> numDefine2;
      r21 = heapClassInst.heap32[r21];
      if (r21 !== 0) {
        r22 = r21 >> numDefine2;
        r22 = heapClassInst.heap32[r22 + numDefine3];
      } else {
        r22 = -1;
      }
      if (r6 !== 0) {
        r23 = r6 >> numDefine2;
        r23 = heapClassInst.heap32[r23 + numDefine3];
      } else {
        r23 = -1;
      }
      r24 = r19 << numDefine2;
      r24 = (r9 + r24) | 0;
      r24 = r24 >> numDefine2;
      r24 = heapClassInst.heap32[r24 + 1];
      if (r24 !== 0) {
        r25 = r24 >> numDefine2;
        r25 = heapClassInst.heap32[r25 + numDefine3];
      } else {
        r25 = -1;
      }
      repeat48: do {
        if (!(r20 > r22)) {
          if (!(r5 !== r21)) {
            if (r23 > r25) {
              break repeat48;
            }
          }
          if (r5 !== r21) {
            break repeat30;
          } else {
            if (r6 !== r24) {
              break repeat30;
            } else {
              r20 = r19 << numDefine2;
              r20 = (r9 + r20) | 0;
              r20 = r20 >> numDefine2;
              r20 = heapClassInst.heap32[r20 + numDefine2];
              if (!(uint(r2) > uint(r20))) {
                break repeat30;
              }
            }
          }
        }
      } while (false);
      r16 = (r16 + -1) | 0;
      continue repeat30;
    }
    r20 = (r8 + r16) | 0;
    if (r15 <= r20) {
      r13 = r13 << numDefine2;
      r10 = (r10 + r13) | 0;
      r10 = r10 >> numDefine2;
      r13 = heapClassInst.heap32[r12 + numDefine3];
      r15 = heapClassInst.heap32[r10 + numDefine2];
      r19 = r19 << numDefine2;
      r19 = (r9 + r19) | 0;
      heapClassInst.heap32[r10] = r21;
      r20 = r16 << numDefine4;
      r19 = r19 >> numDefine2;
      heapClassInst.heap32[r10 + 1] = r24;
      r19 = heapClassInst.heap32[r19 + numDefine2];
      r9 = (r9 + r20) | 0;
      r9 = r9 >> numDefine2;
      heapClassInst.heap32[r10 + numDefine2] = r19;
      r9 = heapClassInst.heap32[r9 + numDefine3];
      heapClassInst.heap32[r12 + numDefine3] = r9;
      r9 = heapClassInst.heap32[r3 + numDefine3];
      r9 = (r9 + r18) | 0;
      r9 = (r9 + r20) | 0;
      r9 = r9 >> numDefine2;
      heapClassInst.heap32[r9] = r14;
      r7 = (r7 + r11) | 0;
      r8 = (r8 + r16) | 0;
      heapClassInst.heap32[r9 + 1] = r17;
      r7 = (r7 + 1) | 0;
      r8 = (r8 + -1) | 0;
      heapClassInst.heap32[r9 + numDefine2] = r15;
      heapClassInst.heap32[r9 + numDefine3] = r13;
    } else {
      r7 = r15;
      r8 = r20;
    }
    if (r7 <= r8) {
      continue repeat1;
    } else {
      break repeat1;
    }
  }
  if (!(r8 <= r1)) {
    heapClassInst.heap32[g0] = r4;
    heapClassInst.heap32[g0 + 1] = r1;
    heapClassInst.heap32[g0 + numDefine2] = r8;
    zn20btAlignedObjectArrayI16btBroadphasePairE17quickSortInternalI29btBroadphasePairSortPredicateEEvTIi(i7);
  }
  if (!(r7 >= r0)) {
    heapClassInst.heap32[g0] = r4;
    heapClassInst.heap32[g0 + 1] = r7;
    heapClassInst.heap32[g0 + numDefine2] = r0;
    zn20btAlignedObjectArrayI16btBroadphasePairE17quickSortInternalI29btBroadphasePairSortPredicateEEvTIi(i7);
  }
  return;
}

function zn20btAxisSweep3InternalItE11sortMaxDownEitP12btDispatcherb(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heap32[fp];
  r2 = r0 << numDefine2;
  r2 = (r1 + r2) | 0;
  r3 = heapClassInst.heap32[fp + numDefine2];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine17];
  r4 = r3 << numDefine2;
  r5 = (r2 + r4) | 0;
  r4 = heapClassInst.heapU16[(r2 + r4) >> 1];
  r6 = heapClassInst.heapU16[(r5 + numDefineNeg4) >> 1];
  if (!(uint(r4) >= uint(r6))) {
    r1 = r1 >> numDefine2;
    r4 = heapClassInst.heap32[fp + numDefine3];
    r6 = heapClassInst.heap32[fp + numDefine4];
    r7 = heapClassInst.heap32[r1 + numDefine15];
    r3 = r3 << numDefine2;
    r2 = (r2 + r3) | 0;
    r2 = heapClassInst.heapU16[(r2 + numDefine2) >> 1];
    r3 = 1;
    r8 = r3 << r0;
    r2 = r2 << numDefine6;
    r8 = r8 & numDefine3;
    r2 = (r7 + r2) | 0;
    r0 = r0 << 1;
    r3 = r3 << r8;
    r2 = (r2 + r0) | 0;
    r3 = r3 & numDefine3;
    r2 = (r2 + numDefine54) | 0;
    r5 = (r5 + numDefine2) | 0;
    repeat3: while (true) {
      r9 = heapClassInst.heapU8[r5 + numDefineNeg6];
      r10 = heapClassInst.heapU16[(r5 + numDefineNeg4) >> 1];
      r9 = r9 & 1;
      if (r9 !== 0) {
        r9 = r10 << numDefine6;
        r7 = (r7 + r9) | 0;
        r7 = (r7 + r0) | 0;
        r9 = heapClassInst.heapU16[(r7 + numDefine54) >> 1];
        r9 = (r9 + 1) | 0;
        heapClassInst.heap16[(r7 + numDefine54) >> 1] = r9;
      } else {
        if (!(r6 === 0)) {
          r9 = heapClassInst.heapU16[r5 >> 1];
          r9 = r9 << numDefine6;
          r11 = r10 << numDefine6;
          r9 = (r7 + r9) | 0;
          r12 = r8 << 1;
          r11 = (r7 + r11) | 0;
          r13 = (r9 + r12) | 0;
          r12 = (r11 + r12) | 0;
          r14 = heapClassInst.heapU16[(r13 + numDefine54) >> 1];
          r15 = heapClassInst.heapU16[(r12 + numDefine48) >> 1];
          if (!(uint(r14) < uint(r15))) {
            r12 = heapClassInst.heapU16[(r12 + numDefine54) >> 1];
            r13 = heapClassInst.heapU16[(r13 + numDefine48) >> 1];
            if (!(uint(r12) < uint(r13))) {
              r12 = r3 << 1;
              r13 = (r9 + r12) | 0;
              r12 = (r11 + r12) | 0;
              r14 = heapClassInst.heapU16[(r13 + numDefine54) >> 1];
              r15 = heapClassInst.heapU16[(r12 + numDefine48) >> 1];
              if (!(uint(r14) < uint(r15))) {
                r12 = heapClassInst.heapU16[(r12 + numDefine54) >> 1];
                r13 = heapClassInst.heapU16[(r13 + numDefine48) >> 1];
                if (!(uint(r12) < uint(r13))) {
                  r12 = heapClassInst.heap32[r1 + numDefine23];
                  r13 = r12 >> numDefine2;
                  r13 = heapClassInst.heap32[r13];
                  r13 = r13 >> numDefine2;
                  r13 = heapClassInst.heap32[r13 + numDefine3];
                  heapClassInst.heap32[g0] = r12;
                  heapClassInst.heap32[g0 + 1] = r9;
                  heapClassInst.heap32[g0 + numDefine2] = r11;
                  heapClassInst.heap32[g0 + numDefine3] = r4;
                  functionTable[r13 >> numDefine2](i7);
                  r12 = heapClassInst.heap32[r1 + numDefine24];
                  if (!(r12 === 0)) {
                    r13 = r12 >> numDefine2;
                    r13 = heapClassInst.heap32[r13];
                    r13 = r13 >> numDefine2;
                    r13 = heapClassInst.heap32[r13 + numDefine3];
                    heapClassInst.heap32[g0] = r12;
                    heapClassInst.heap32[g0 + 1] = r9;
                    heapClassInst.heap32[g0 + numDefine2] = r11;
                    heapClassInst.heap32[g0 + numDefine3] = r4;
                    functionTable[r13 >> numDefine2](i7);
                  }
                }
              }
            }
          }
        }
        r10 = r10 << numDefine6;
        r7 = (r7 + r10) | 0;
        r7 = (r7 + r0) | 0;
        r10 = heapClassInst.heapU16[(r7 + numDefine48) >> 1];
        r10 = (r10 + 1) | 0;
        heapClassInst.heap16[(r7 + numDefine48) >> 1] = r10;
      }
      r7 = heapClassInst.heapU16[r2 >> 1];
      r7 = (r7 + -1) | 0;
      heapClassInst.heap16[r2 >> 1] = r7;
      r7 = heapClassInst.heapU16[(r5 + numDefineNeg2) >> 1];
      r9 = heapClassInst.heapU16[r5 >> 1];
      r10 = heapClassInst.heapU16[(r5 + numDefineNeg4) >> 1];
      r11 = heapClassInst.heapU16[(r5 + numDefineNeg6) >> 1];
      heapClassInst.heap16[(r5 + numDefineNeg2) >> 1] = r11;
      heapClassInst.heap16[r5 >> 1] = r10;
      heapClassInst.heap16[(r5 + numDefineNeg6) >> 1] = r7;
      heapClassInst.heap16[(r5 + numDefineNeg4) >> 1] = r9;
      r9 = heapClassInst.heapU16[(r5 + numDefineNeg10) >> 1];
      if (uint(r7) >= uint(r9)) {
        break repeat3;
      } else {
        r7 = heapClassInst.heap32[r1 + numDefine15];
        r5 = (r5 + numDefineNeg4) | 0;
        continue repeat3;
      }
    }
  }
  return;
}

function zn20btAxisSweep3InternalItE11sortMinDownEitP12btDispatcherb(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let r16: number = 0;
  let r17: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heap32[fp];
  r2 = r0 << numDefine2;
  r2 = (r1 + r2) | 0;
  r3 = heapClassInst.heap32[fp + numDefine2];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine17];
  r3 = r3 << numDefine2;
  r4 = (r2 + r3) | 0;
  r2 = heapClassInst.heapU16[(r2 + r3) >> 1];
  r3 = heapClassInst.heapU16[(r4 + numDefineNeg4) >> 1];
  if (!(uint(r2) >= uint(r3))) {
    r1 = r1 >> numDefine2;
    r2 = heapClassInst.heap32[fp + numDefine3];
    r3 = heapClassInst.heap32[r1 + numDefine15];
    r5 = heapClassInst.heapU16[(r4 + numDefine2) >> 1];
    r6 = 1;
    r7 = r6 << r0;
    r7 = r7 & numDefine3;
    r6 = r6 << r7;
    r5 = r5 << numDefine6;
    r5 = (r3 + r5) | 0;
    r6 = r6 & numDefine3;
    r0 = r0 << 1;
    r8 = (r5 + numDefine48) | 0;
    r7 = r7 << 1;
    r9 = (r5 + numDefine54) | 0;
    r6 = r6 << 1;
    r10 = (r8 + r0) | 0;
    r11 = (r9 + r7) | 0;
    r12 = (r8 + r7) | 0;
    r9 = (r9 + r6) | 0;
    r8 = (r8 + r6) | 0;
    r4 = (r4 + numDefine2) | 0;
    repeat3: while (true) {
      r13 = heapClassInst.heapU8[r4 + numDefineNeg6];
      r14 = heapClassInst.heapU16[(r4 + numDefineNeg4) >> 1];
      r13 = r13 & 1;
      if (r13 === 0) {
        r13 = r14 << numDefine6;
        r3 = (r3 + r13) | 0;
        r3 = (r3 + r0) | 0;
        r13 = heapClassInst.heapU16[(r3 + numDefine48) >> 1];
        r13 = (r13 + 1) | 0;
        heapClassInst.heap16[(r3 + numDefine48) >> 1] = r13;
      } else {
        if (!(r2 === 0)) {
          r13 = r14 << numDefine6;
          r13 = (r3 + r13) | 0;
          r15 = (r13 + r7) | 0;
          r16 = heapClassInst.heapU16[r11 >> 1];
          r17 = heapClassInst.heapU16[(r15 + numDefine48) >> 1];
          if (!(uint(r16) < uint(r17))) {
            r15 = heapClassInst.heapU16[(r15 + numDefine54) >> 1];
            r16 = heapClassInst.heapU16[r12 >> 1];
            if (!(uint(r15) < uint(r16))) {
              r15 = (r13 + r6) | 0;
              r16 = heapClassInst.heapU16[r9 >> 1];
              r17 = heapClassInst.heapU16[(r15 + numDefine48) >> 1];
              if (!(uint(r16) < uint(r17))) {
                r15 = heapClassInst.heapU16[(r15 + numDefine54) >> 1];
                r16 = heapClassInst.heapU16[r8 >> 1];
                if (!(uint(r15) < uint(r16))) {
                  r15 = heapClassInst.heap32[r1 + numDefine23];
                  r16 = r15 >> numDefine2;
                  r16 = heapClassInst.heap32[r16];
                  r16 = r16 >> numDefine2;
                  r16 = heapClassInst.heap32[r16 + numDefine2];
                  heapClassInst.heap32[g0] = r15;
                  heapClassInst.heap32[g0 + 1] = r5;
                  heapClassInst.heap32[g0 + numDefine2] = r13;
                  functionTable[r16 >> numDefine2](i7);
                  r15 = heapClassInst.heap32[r1 + numDefine24];
                  if (!(r15 === 0)) {
                    r16 = r15 >> numDefine2;
                    r16 = heapClassInst.heap32[r16];
                    r16 = r16 >> numDefine2;
                    r16 = heapClassInst.heap32[r16 + numDefine2];
                    heapClassInst.heap32[g0] = r15;
                    heapClassInst.heap32[g0 + 1] = r5;
                    heapClassInst.heap32[g0 + numDefine2] = r13;
                    functionTable[r16 >> numDefine2](i7);
                  }
                }
              }
            }
          }
        }
        r14 = r14 << numDefine6;
        r3 = (r3 + r14) | 0;
        r3 = (r3 + r0) | 0;
        r14 = heapClassInst.heapU16[(r3 + numDefine54) >> 1];
        r14 = (r14 + 1) | 0;
        heapClassInst.heap16[(r3 + numDefine54) >> 1] = r14;
      }
      r3 = heapClassInst.heapU16[r10 >> 1];
      r3 = (r3 + -1) | 0;
      heapClassInst.heap16[r10 >> 1] = r3;
      r3 = heapClassInst.heapU16[(r4 + numDefineNeg2) >> 1];
      r13 = heapClassInst.heapU16[r4 >> 1];
      r14 = heapClassInst.heapU16[(r4 + numDefineNeg4) >> 1];
      r15 = heapClassInst.heapU16[(r4 + numDefineNeg6) >> 1];
      heapClassInst.heap16[(r4 + numDefineNeg2) >> 1] = r15;
      heapClassInst.heap16[r4 >> 1] = r14;
      heapClassInst.heap16[(r4 + numDefineNeg6) >> 1] = r3;
      heapClassInst.heap16[(r4 + numDefineNeg4) >> 1] = r13;
      r13 = heapClassInst.heapU16[(r4 + numDefineNeg10) >> 1];
      if (uint(r3) >= uint(r13)) {
        break repeat3;
      } else {
        r3 = heapClassInst.heap32[r1 + numDefine15];
        r4 = (r4 + numDefineNeg4) | 0;
        continue repeat3;
      }
    }
  }
  return;
}

function znk20btAxisSweep3InternalItE8quantizeEPtRK9btVector3i(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  f0 = heapClassInst.heapFloat[fp + numDefine2];
  f1 = heapClassInst.heapFloat[r1 + numDefine2];
  f2 = heapClassInst.heapFloat[fp + numDefine4];
  f3 = heapClassInst.heapFloat[r1 + numDefine4];
  f4 = heapClassInst.heapFloat[fp + numDefine3];
  f5 = heapClassInst.heapFloat[r1 + numDefine3];
  f0 = f0 - f1;
  f1 = heapClassInst.heapFloat[r1 + numDefine10];
  f2 = f2 - f3;
  f3 = heapClassInst.heapFloat[r1 + numDefine12];
  f4 = f4 - f5;
  f5 = heapClassInst.heapFloat[r1 + numDefine11];
  f0 = f0 * f1;
  r1 = heapClassInst.heap32[fp + 1];
  r2 = heapClassInst.heap32[fp + numDefine5];
  f1 = f2 * f3;
  f2 = f4 * f5;
  f3 = 0;
  if (f0 > f3) {
    r3 = heapClassInst.heapU16[(r0 + numDefine6) >> 1];
    f4 = r3;
    if (f0 < f4) {
      r3 = heapClassInst.heapU16[(r0 + numDefine4) >> 1];
      r4 = Math.floor(f0);
      r3 = r3 & r4;
      r3 = r3 | r2;
    } else {
      r4 = heapClassInst.heapU16[(r0 + numDefine4) >> 1];
      r3 = r4 & r3;
      r3 = r3 | r2;
    }
  } else {
    r3 = r2;
  }
  heapClassInst.heap16[r1 >> 1] = r3;
  if (f2 > f3) {
    r3 = heapClassInst.heapU16[(r0 + numDefine6) >> 1];
    f0 = r3;
    if (f2 < f0) {
      r3 = heapClassInst.heapU16[(r0 + numDefine4) >> 1];
      r4 = Math.floor(f2);
      r3 = r3 & r4;
      r3 = r3 | r2;
    } else {
      r4 = heapClassInst.heapU16[(r0 + numDefine4) >> 1];
      r3 = r4 & r3;
      r3 = r3 | r2;
    }
  } else {
    r3 = r2;
  }
  heapClassInst.heap16[(r1 + numDefine2) >> 1] = r3;
  if (f1 > f3) {
    r3 = heapClassInst.heapU16[(r0 + numDefine6) >> 1];
    f0 = r3;
    if (f1 < f0) {
      r0 = heapClassInst.heapU16[(r0 + numDefine4) >> 1];
      r3 = Math.floor(f1);
      r0 = r0 & r3;
      r2 = r0 | r2;
    } else {
      r0 = heapClassInst.heapU16[(r0 + numDefine4) >> 1];
      r0 = r0 & r3;
      r2 = r0 | r2;
    }
  }
  heapClassInst.heap16[(r1 + numDefine4) >> 1] = r2;
  return;
}

function waMandreelAudioUpdate(sp: number): void {}

function mandreelAudioIsLogEnabled(sp: number): void {
  commonVariable.rg0 = 0;
}

function mandreelFlashSocketsGetFlashMovieObject(movieName: string): void {}

function mandreelAudioGetAudioDriverName(sp: number): void {
  sp = sp;
  let namePtr = heapClassInst.heap32[sp >> numDefine2];
  sp += numDefine4;
  fillPtrFromString(namePtr, commonVariable.mandreelAudioDriver);
}

function zn20btAlignedObjectArrayI18btQuantizedBvhNodeE7reserveEi(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = r0 >> numDefine2;
  r3 = heapClassInst.heap32[r2 + numDefine2];
  if (!(r3 >= r1)) {
    if (r1 !== 0) {
      r3 = gNumAlignedAllocs;
      r3 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r3];
      r5 = r1 << numDefine4;
      r4 = (r4 + 1) | 0;
      r5 = r5 | numDefine3;
      heapClassInst.heap32[r3] = r4;
      r3 = (r5 + numDefine16) | 0;
      heapClassInst.heap32[g0] = r3;
      mallocNew(i7);
      r3 = commonVariable.rg0;
      if (r3 !== 0) {
        r4 = 0;
        r5 = (r3 + numDefine4) | 0;
        r4 = (r4 - r5) | 0;
        r4 = r4 & numDefine15;
        r4 = (r3 + r4) | 0;
        r5 = (r4 + numDefine4) | 0;
        r4 = r4 >> numDefine2;
        heapClassInst.heap32[r4] = r3;
        r3 = r5;
      }
    } else {
      r3 = 0;
    }
    r4 = heapClassInst.heap32[r2 + 1];
    r5 = (r0 + numDefine12) | 0;
    if (r4 < 1) {
      r4 = r5 >> numDefine2;
      r7 = heapClassInst.heap32[r4];
    } else {
      r6 = 0;
      repeat11: while (true) {
        r7 = r5 >> numDefine2;
        r7 = heapClassInst.heap32[r7];
        r8 = r6 << numDefine4;
        r9 = heapClassInst.heapU16[(r7 + r8) >> 1];
        r10 = (r7 + r8) | 0;
        heapClassInst.heap16[(r3 + r8) >> 1] = r9;
        r8 = (r3 + r8) | 0;
        r9 = heapClassInst.heapU16[(r10 + numDefine2) >> 1];
        heapClassInst.heap16[(r8 + numDefine2) >> 1] = r9;
        r9 = heapClassInst.heapU16[(r10 + numDefine4) >> 1];
        heapClassInst.heap16[(r8 + numDefine4) >> 1] = r9;
        r9 = heapClassInst.heapU16[(r10 + numDefine6) >> 1];
        heapClassInst.heap16[(r8 + numDefine6) >> 1] = r9;
        r9 = heapClassInst.heapU16[(r10 + numDefine8) >> 1];
        heapClassInst.heap16[(r8 + numDefine8) >> 1] = r9;
        r9 = heapClassInst.heapU16[(r10 + numDefine10) >> 1];
        r10 = r10 >> numDefine2;
        heapClassInst.heap16[(r8 + numDefine10) >> 1] = r9;
        r6 = (r6 + 1) | 0;
        r8 = r8 >> numDefine2;
        r9 = heapClassInst.heap32[r10 + numDefine3];
        heapClassInst.heap32[r8 + numDefine3] = r9;
        if (!(r4 !== r6)) {
          break repeat11;
        }
      }
      r5 = (r0 + numDefine12) | 0;
    }
    if (!(r7 === 0)) {
      r4 = heapClassInst.heapU8[r0 + numDefine16];
      if (!(r4 === 0)) {
        r4 = gNumAlignedFree;
        r4 = r4 >> numDefine2;
        r6 = heapClassInst.heap32[r4];
        r6 = (r6 + 1) | 0;
        r7 = r7 >> numDefine2;
        heapClassInst.heap32[r4] = r6;
        r4 = heapClassInst.heap32[r7 + -1];
        heapClassInst.heap32[g0] = r4;
        free(i7);
      }
      r4 = r5 >> numDefine2;
      heapClassInst.heap32[r4] = 0;
    }
    r4 = 1;
    r5 = r5 >> numDefine2;
    heapClassInst.heap8[r0 + numDefine16] = r4;
    heapClassInst.heap32[r5] = r3;
    heapClassInst.heap32[r2 + numDefine2] = r1;
  }
  return;
}

function znk14btQuantizedBvh8quantizeEPtRK9btVector3i(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heapU8[r0 + numDefine60];
  if (r1 !== 0) {
    r1 = heapClassInst.heap32[fp + numDefine2];
    r1 = r1 >> numDefine2;
    f0 = heapClassInst.heapFloat[r1];
    r0 = r0 >> numDefine2;
    f1 = heapClassInst.heapFloat[r0 + numDefine5];
    if (f0 <= f1) {
      f1 = heapClassInst.heapFloat[r1 + 1];
      f2 = heapClassInst.heapFloat[r0 + numDefine6];
      if (f1 <= f2) {
        f2 = heapClassInst.heapFloat[r1 + numDefine2];
        f3 = heapClassInst.heapFloat[r0 + numDefine7];
        if (f2 <= f3) {
          f3 = heapClassInst.heapFloat[r0 + 1];
          if (f0 >= f3) {
            f4 = heapClassInst.heapFloat[r0 + numDefine2];
            if (f1 >= f4) {
              f5 = heapClassInst.heapFloat[r0 + numDefine3];
              if (f2 >= f5) {
                r1 = heapClassInst.heap32[fp + 1];
                r2 = heapClassInst.heap32[fp + numDefine3];
                f2 = f2 - f5;
                f5 = heapClassInst.heapFloat[r0 + numDefine11];
                f1 = f1 - f4;
                f4 = heapClassInst.heapFloat[r0 + numDefine10];
                f0 = f0 - f3;
                f3 = heapClassInst.heapFloat[r0 + numDefine9];
                f2 = f2 * f5;
                f1 = f1 * f4;
                f0 = f0 * f3;
                if (r2 === 0) {
                  r0 = Math.floor(f0);
                  r2 = Math.floor(f1);
                  r0 = r0 & numDefine65534;
                  r3 = Math.floor(f2);
                  r2 = r2 & numDefine65534;
                  heapClassInst.heap16[r1 >> 1] = r0;
                  r0 = r3 & numDefine65534;
                } else {
                  f3 = 1;
                  f0 = f0 + f3;
                  f1 = f1 + f3;
                  r0 = Math.floor(f0);
                  f0 = f2 + f3;
                  r2 = Math.floor(f1);
                  r0 = r0 | 1;
                  r3 = Math.floor(f0);
                  r2 = r2 | 1;
                  heapClassInst.heap16[r1 >> 1] = r0;
                  r0 = r3 | 1;
                }
                heapClassInst.heap16[(r1 + numDefine2) >> 1] = r2;
                heapClassInst.heap16[(r1 + numDefine4) >> 1] = r0;
                return;
              } else {
                r0 = twoEStr9;
                r1 = twoEStr313;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r1;
                heapClassInst.heap32[g0 + numDefine2] = numDefine361;
                assertNew(i7);
              }
            } else {
              r0 = twoEStr820;
              r1 = twoEStr313;
              heapClassInst.heap32[g0] = r0;
              heapClassInst.heap32[g0 + 1] = r1;
              heapClassInst.heap32[g0 + numDefine2] = numDefine360;
              assertNew(i7);
            }
          } else {
            r0 = twoEStr717;
            r1 = twoEStr313;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = numDefine359;
            assertNew(i7);
          }
        } else {
          r0 = twoEStr616;
          r1 = twoEStr313;
          heapClassInst.heap32[g0] = r0;
          heapClassInst.heap32[g0 + 1] = r1;
          heapClassInst.heap32[g0 + numDefine2] = numDefine357;
          assertNew(i7);
        }
      } else {
        r0 = twoEStr515;
        r1 = twoEStr313;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r1;
        heapClassInst.heap32[g0 + numDefine2] = numDefine356;
        assertNew(i7);
      }
    } else {
      r0 = twoEStr414;
      r1 = twoEStr313;
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r1;
      heapClassInst.heap32[g0 + numDefine2] = numDefine355;
      assertNew(i7);
    }
  } else {
    r0 = twoEStr212;
    r1 = twoEStr313;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r1;
    heapClassInst.heap32[g0 + numDefine2] = numDefine353;
    assertNew(i7);
  }
}

function zn6btDbvt9collideTVEPK10btDbvtNodeRK12btDbvtAabbMmRNS8ICollideE(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  if (!(r0 === 0)) {
    r1 = heapClassInst.heap32[fp + 1];
    r2 = heapClassInst.heap32[fp + numDefine2];
    r3 = gNumAlignedAllocs;
    r1 = r1 >> numDefine2;
    r3 = r3 >> numDefine2;
    r4 = heapClassInst.heap32[r3];
    f0 = heapClassInst.heapFloat[r1];
    f1 = heapClassInst.heapFloat[r1 + 1];
    f2 = heapClassInst.heapFloat[r1 + numDefine2];
    f3 = heapClassInst.heapFloat[r1 + numDefine4];
    f4 = heapClassInst.heapFloat[r1 + numDefine5];
    f5 = heapClassInst.heapFloat[r1 + numDefine6];
    r1 = (r4 + 1) | 0;
    heapClassInst.heap32[r3] = r1;
    heapClassInst.heap32[g0] = numDefine275;
    mallocNew(i7);
    r1 = commonVariable.rg0;
    if (r1 !== 0) {
      r4 = 0;
      r5 = (r1 + numDefine4) | 0;
      r4 = (r4 - r5) | 0;
      r4 = r4 & numDefine15;
      r4 = (r1 + r4) | 0;
      r5 = (r4 + numDefine4) | 0;
      r4 = r4 >> numDefine2;
      heapClassInst.heap32[r4] = r1;
      r1 = r5;
    }
    r4 = 1;
    r5 = numDefine64;
    r6 = r1 >> numDefine2;
    heapClassInst.heap32[r6] = r0;
    repeat6: while (true) {
      r0 = r4;
      r4 = (r0 + -1) | 0;
      r6 = r4 << numDefine2;
      r6 = (r1 + r6) | 0;
      r6 = r6 >> numDefine2;
      r6 = heapClassInst.heap32[r6];
      r7 = r6 >> numDefine2;
      f6 = heapClassInst.heapFloat[r7];
      if (f6 <= f3) {
        f6 = heapClassInst.heapFloat[r7 + numDefine4];
        if (!(f6 < f0)) {
          f6 = heapClassInst.heapFloat[r7 + 1];
          if (!(f6 > f4)) {
            f6 = heapClassInst.heapFloat[r7 + numDefine5];
            if (!(f6 < f1)) {
              f6 = heapClassInst.heapFloat[r7 + numDefine2];
              if (!(f6 > f5)) {
                f6 = heapClassInst.heapFloat[r7 + numDefine6];
                if (!(f6 < f2)) {
                  r8 = heapClassInst.heap32[r7 + numDefine10];
                  if (r8 === 0) {
                    r0 = r2 >> numDefine2;
                    r0 = heapClassInst.heap32[r0];
                    r0 = r0 >> numDefine2;
                    r0 = heapClassInst.heap32[r0 + numDefine3];
                    heapClassInst.heap32[g0] = r2;
                    heapClassInst.heap32[g0 + 1] = r6;
                    functionTable[r0 >> numDefine2](i7);
                  } else {
                    r6 = heapClassInst.heap32[r7 + numDefine9];
                    if (r5 === r4) {
                      r8 = 1;
                      r9 = r4 << 1;
                      r8 = r4 === 0 ? r8 : r9;
                      if (!(r5 >= r8)) {
                        if (r8 !== 0) {
                          r5 = heapClassInst.heap32[r3];
                          r9 = r8 << numDefine2;
                          r5 = (r5 + 1) | 0;
                          r9 = r9 | numDefine3;
                          heapClassInst.heap32[r3] = r5;
                          r5 = (r9 + numDefine16) | 0;
                          heapClassInst.heap32[g0] = r5;
                          mallocNew(i7);
                          r9 = commonVariable.rg0;
                          if (r9 !== 0) {
                            r5 = 0;
                            r10 = (r9 + numDefine4) | 0;
                            r5 = (r5 - r10) | 0;
                            r5 = r5 & numDefine15;
                            r5 = (r9 + r5) | 0;
                            r10 = (r5 + numDefine4) | 0;
                            r5 = r5 >> numDefine2;
                            heapClassInst.heap32[r5] = r9;
                            r9 = r10;
                          }
                        } else {
                          r9 = 0;
                        }
                        if (!(r4 < 1)) {
                          r4 = (r0 + -1) | 0;
                          r5 = r1;
                          r10 = r9;
                          repeat28: while (true) {
                            r11 = r5 >> numDefine2;
                            r4 = (r4 + -1) | 0;
                            r12 = (r10 + numDefine4) | 0;
                            r5 = (r5 + numDefine4) | 0;
                            r10 = r10 >> numDefine2;
                            r11 = heapClassInst.heap32[r11];
                            heapClassInst.heap32[r10] = r11;
                            r10 = r12;
                            if (!(r4 !== 0)) {
                              break repeat28;
                            }
                          }
                        }
                        if (r1 !== 0) {
                          r4 = gNumAlignedFree;
                          r4 = r4 >> numDefine2;
                          r5 = heapClassInst.heap32[r4];
                          r5 = (r5 + 1) | 0;
                          r1 = r1 >> numDefine2;
                          heapClassInst.heap32[r4] = r5;
                          r1 = heapClassInst.heap32[r1 + -1];
                          heapClassInst.heap32[g0] = r1;
                          free(i7);
                          r5 = r8;
                          r1 = r9;
                        } else {
                          r5 = r8;
                          r1 = r9;
                        }
                      }
                    }
                    r4 = r0 << numDefine2;
                    r8 = (r1 + r4) | 0;
                    r8 = r8 >> numDefine2;
                    heapClassInst.heap32[r8 + -1] = r6;
                    r6 = heapClassInst.heap32[r7 + numDefine10];
                    if (r5 === r0) {
                      r7 = 1;
                      r8 = r0 << 1;
                      r7 = r0 === 0 ? r7 : r8;
                      if (!(r5 >= r7)) {
                        if (r7 !== 0) {
                          r5 = heapClassInst.heap32[r3];
                          r8 = r7 << numDefine2;
                          r5 = (r5 + 1) | 0;
                          r8 = r8 | numDefine3;
                          heapClassInst.heap32[r3] = r5;
                          r5 = (r8 + numDefine16) | 0;
                          heapClassInst.heap32[g0] = r5;
                          mallocNew(i7);
                          r8 = commonVariable.rg0;
                          if (r8 !== 0) {
                            r5 = 0;
                            r9 = (r8 + numDefine4) | 0;
                            r5 = (r5 - r9) | 0;
                            r5 = r5 & numDefine15;
                            r5 = (r8 + r5) | 0;
                            r9 = (r5 + numDefine4) | 0;
                            r5 = r5 >> numDefine2;
                            heapClassInst.heap32[r5] = r8;
                            r8 = r9;
                          }
                        } else {
                          r8 = 0;
                        }
                        repeat43: do {
                          if (!(r0 < 1)) {
                            r5 = r1;
                            r9 = r8;
                            r10 = r0;
                            while (true) {
                              r11 = r5 >> numDefine2;
                              r10 = (r10 + -1) | 0;
                              r12 = (r9 + numDefine4) | 0;
                              r5 = (r5 + numDefine4) | 0;
                              r9 = r9 >> numDefine2;
                              r11 = heapClassInst.heap32[r11];
                              heapClassInst.heap32[r9] = r11;
                              r9 = r12;
                              if (!(r10 !== 0)) {
                                break repeat43;
                              }
                            }
                          }
                        } while (false);
                        if (r1 !== 0) {
                          r5 = gNumAlignedFree;
                          r5 = r5 >> numDefine2;
                          r9 = heapClassInst.heap32[r5];
                          r9 = (r9 + 1) | 0;
                          r1 = r1 >> numDefine2;
                          heapClassInst.heap32[r5] = r9;
                          r1 = heapClassInst.heap32[r1 + -1];
                          heapClassInst.heap32[g0] = r1;
                          free(i7);
                          r5 = r7;
                          r1 = r8;
                        } else {
                          r5 = r7;
                          r1 = r8;
                        }
                      }
                    }
                    r7 = (r1 + r4) | 0;
                    r4 = (r0 + 1) | 0;
                    r0 = r7 >> numDefine2;
                    heapClassInst.heap32[r0] = r6;
                  }
                }
              }
            }
          }
        }
      }
      if (!(r4 > 0)) {
        break repeat6;
      }
    }
    if (!(r1 === 0)) {
      r0 = gNumAlignedFree;
      r0 = r0 >> numDefine2;
      r2 = heapClassInst.heap32[r0];
      r2 = (r2 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r0] = r2;
      r0 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r0;
      free(i7);
    }
  }
  return;
}

function znk14btQuantizedBvh9serializeEPvjb(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1 + numDefine38];
  r3 = heapClassInst.heap32[r1 + numDefine42];
  if (r3 === r2) {
    r3 = heapClassInst.heap32[fp + 1];
    r4 = heapClassInst.heap32[fp + numDefine3];
    r5 = ztv14btQuantizedBvh;
    r6 = r3 >> numDefine2;
    r5 = (r5 + numDefine8) | 0;
    heapClassInst.heap32[r1 + numDefine42] = r2;
    heapClassInst.heap32[r6] = r5;
    r2 = 0;
    heapClassInst.heap32[r6 + numDefine13] = numDefine277;
    r5 = 1;
    heapClassInst.heap8[r3 + numDefine60] = r2;
    heapClassInst.heap8[r3 + numDefine80] = r5;
    heapClassInst.heap32[r6 + numDefine19] = 0;
    heapClassInst.heap32[r6 + numDefine17] = 0;
    heapClassInst.heap32[r6 + numDefine18] = 0;
    heapClassInst.heap8[r3 + numDefine100] = r5;
    heapClassInst.heap32[r6 + numDefine24] = 0;
    heapClassInst.heap32[r6 + numDefine22] = 0;
    heapClassInst.heap32[r6 + numDefine23] = 0;
    heapClassInst.heap8[r3 + numDefine120] = r5;
    heapClassInst.heap32[r6 + numDefine29] = 0;
    heapClassInst.heap32[r6 + numDefine27] = 0;
    heapClassInst.heap32[r6 + numDefine28] = 0;
    heapClassInst.heap8[r3 + numDefine140] = r5;
    heapClassInst.heap32[r6 + numDefine34] = 0;
    heapClassInst.heap32[r6 + numDefine32] = 0;
    heapClassInst.heap32[r6 + numDefine33] = 0;
    heapClassInst.heap32[r6 + numDefine36] = 0;
    heapClassInst.heap8[r3 + numDefine164] = r5;
    heapClassInst.heap32[r6 + numDefine40] = 0;
    heapClassInst.heap32[r6 + numDefine38] = 0;
    heapClassInst.heap32[r6 + numDefine39] = 0;
    heapClassInst.heap32[r6 + numDefine42] = 0;
    heapClassInst.heap32[r6 + 1] = numDefineNeg88609;
    heapClassInst.heap32[r6 + numDefine2] = numDefineNeg88609;
    heapClassInst.heap32[r6 + numDefine3] = numDefineNeg88609;
    heapClassInst.heap32[r6 + numDefine4] = 0;
    heapClassInst.heap32[r6 + numDefine5] = numDefine95039;
    heapClassInst.heap32[r6 + numDefine6] = numDefine95039;
    heapClassInst.heap32[r6 + numDefine7] = numDefine95039;
    heapClassInst.heap32[r6 + numDefine8] = 0;
    r7 = heapClassInst.heap32[r1 + numDefine14];
    if (r4 === 0) {
      heapClassInst.heap32[r6 + numDefine14] = r7;
      heapClassInst.heap32[r6 + 1] = heapClassInst.heap32[r1 + 1];
      heapClassInst.heap32[r6 + numDefine2] = heapClassInst.heap32[r1 + numDefine2];
      heapClassInst.heap32[r6 + numDefine3] = heapClassInst.heap32[r1 + numDefine3];
      heapClassInst.heap32[r6 + numDefine4] = heapClassInst.heap32[r1 + numDefine4];
      heapClassInst.heap32[r6 + numDefine5] = heapClassInst.heap32[r1 + numDefine5];
      heapClassInst.heap32[r6 + numDefine6] = heapClassInst.heap32[r1 + numDefine6];
      heapClassInst.heap32[r6 + numDefine7] = heapClassInst.heap32[r1 + numDefine7];
      heapClassInst.heap32[r6 + numDefine8] = heapClassInst.heap32[r1 + numDefine8];
      heapClassInst.heap32[r6 + numDefine9] = heapClassInst.heap32[r1 + numDefine9];
      heapClassInst.heap32[r6 + numDefine10] = heapClassInst.heap32[r1 + numDefine10];
      heapClassInst.heap32[r6 + numDefine11] = heapClassInst.heap32[r1 + numDefine11];
      heapClassInst.heap32[r6 + numDefine12] = heapClassInst.heap32[r1 + numDefine12];
      r7 = heapClassInst.heap32[r1 + numDefine36];
      heapClassInst.heap32[r6 + numDefine36] = r7;
      r7 = heapClassInst.heap32[r1 + numDefine42];
    } else {
      r8 = r7 << numDefine8;
      r9 = r7 >>> numDefine8;
      r10 = r7 << numDefine24;
      r8 = r8 & numDefine11680;
      r9 = r9 & numDefine65280;
      r7 = r7 >>> numDefine24;
      r8 = r10 | r8;
      r7 = r9 | r7;
      r7 = r8 | r7;
      heapClassInst.heap32[r6 + numDefine14] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine7];
      heapClassInst.heap8[r3 + numDefine4] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine6];
      heapClassInst.heap8[r3 + numDefine5] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine5];
      heapClassInst.heap8[r3 + numDefine6] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine4];
      heapClassInst.heap8[r3 + numDefine7] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine11];
      heapClassInst.heap8[r3 + numDefine8] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine10];
      heapClassInst.heap8[r3 + numDefine9] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine9];
      heapClassInst.heap8[r3 + numDefine10] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine8];
      heapClassInst.heap8[r3 + numDefine11] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine15];
      heapClassInst.heap8[r3 + numDefine12] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine14];
      heapClassInst.heap8[r3 + numDefine13] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine13];
      heapClassInst.heap8[r3 + numDefine14] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine12];
      heapClassInst.heap8[r3 + numDefine15] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine19];
      heapClassInst.heap8[r3 + numDefine16] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine18];
      heapClassInst.heap8[r3 + numDefine17] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine17];
      heapClassInst.heap8[r3 + numDefine18] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine16];
      heapClassInst.heap8[r3 + numDefine19] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine23];
      heapClassInst.heap8[r3 + numDefine20] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine22];
      heapClassInst.heap8[r3 + numDefine21] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine21];
      heapClassInst.heap8[r3 + numDefine22] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine20];
      heapClassInst.heap8[r3 + numDefine23] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine27];
      heapClassInst.heap8[r3 + numDefine24] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine26];
      heapClassInst.heap8[r3 + numDefine25] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine25];
      heapClassInst.heap8[r3 + numDefine26] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine24];
      heapClassInst.heap8[r3 + numDefine27] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine31];
      heapClassInst.heap8[r3 + numDefine28] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine30];
      heapClassInst.heap8[r3 + numDefine29] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine29];
      heapClassInst.heap8[r3 + numDefine30] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine28];
      heapClassInst.heap8[r3 + numDefine31] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine35];
      heapClassInst.heap8[r3 + numDefine32] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine34];
      heapClassInst.heap8[r3 + numDefine33] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine33];
      heapClassInst.heap8[r3 + numDefine34] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine32];
      heapClassInst.heap8[r3 + numDefine35] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine39];
      heapClassInst.heap8[r3 + numDefine36] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine38];
      heapClassInst.heap8[r3 + numDefine37] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine37];
      heapClassInst.heap8[r3 + numDefine38] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine36];
      heapClassInst.heap8[r3 + numDefine39] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine43];
      heapClassInst.heap8[r3 + numDefine40] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine42];
      heapClassInst.heap8[r3 + numDefine41] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine41];
      heapClassInst.heap8[r3 + numDefine42] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine40];
      heapClassInst.heap8[r3 + numDefine43] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine47];
      heapClassInst.heap8[r3 + numDefine44] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine46];
      heapClassInst.heap8[r3 + numDefine45] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine45];
      heapClassInst.heap8[r3 + numDefine46] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine44];
      heapClassInst.heap8[r3 + numDefine47] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine51];
      heapClassInst.heap8[r3 + numDefine48] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine50];
      heapClassInst.heap8[r3 + numDefine49] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine49];
      heapClassInst.heap8[r3 + numDefine50] = r7;
      r7 = heapClassInst.heapU8[r0 + numDefine48];
      heapClassInst.heap8[r3 + numDefine51] = r7;
      r7 = heapClassInst.heap32[r1 + numDefine36];
      r8 = r7 << numDefine8;
      r9 = r7 >>> numDefine8;
      r10 = r7 << numDefine24;
      r8 = r8 & numDefine11680;
      r9 = r9 & numDefine65280;
      r7 = r7 >>> numDefine24;
      r8 = r10 | r8;
      r7 = r9 | r7;
      r7 = r8 | r7;
      heapClassInst.heap32[r6 + numDefine36] = r7;
      r7 = heapClassInst.heap32[r1 + numDefine42];
      r8 = r7 << numDefine8;
      r9 = r7 >>> numDefine8;
      r10 = r7 << numDefine24;
      r8 = r8 & numDefine11680;
      r9 = r9 & numDefine65280;
      r7 = r7 >>> numDefine24;
      r8 = r10 | r8;
      r7 = r9 | r7;
      r7 = r8 | r7;
    }
    heapClassInst.heap32[r6 + numDefine42] = r7;
    r7 = heapClassInst.heapU8[r0 + numDefine60];
    heapClassInst.heap8[r3 + numDefine60] = r7;
    r7 = (r3 + numDefine172) | 0;
    r8 = heapClassInst.heap32[r1 + numDefine14];
    r0 = heapClassInst.heapU8[r0 + numDefine60];
    if (r0 === 0) {
      r0 = 0;
      heapClassInst.heap8[r3 + numDefine100] = r0;
      heapClassInst.heap32[r6 + numDefine24] = r7;
      heapClassInst.heap32[r6 + numDefine22] = r8;
      heapClassInst.heap32[r6 + numDefine23] = r8;
      repeat9: do {
        if (r4 !== 0) {
          if (!(r8 < 1)) {
            r5 = (r5 - r8) | 0;
            while (true) {
              r2 = r0 << numDefine6;
              r9 = heapClassInst.heap32[r1 + numDefine24];
              r9 = (r9 - r2) | 0;
              r10 = heapClassInst.heapU8[r9 + numDefine3];
              r7 = (r7 - r2) | 0;
              heapClassInst.heap8[r7] = r10;
              r10 = heapClassInst.heapU8[r9 + numDefine2];
              heapClassInst.heap8[r7 + 1] = r10;
              r10 = heapClassInst.heapU8[r9 + 1];
              heapClassInst.heap8[r7 + numDefine2] = r10;
              r10 = heapClassInst.heapU8[r9];
              heapClassInst.heap8[r7 + numDefine3] = r10;
              r10 = heapClassInst.heapU8[r9 + numDefine7];
              heapClassInst.heap8[r7 + numDefine4] = r10;
              r10 = heapClassInst.heapU8[r9 + numDefine6];
              heapClassInst.heap8[r7 + numDefine5] = r10;
              r10 = heapClassInst.heapU8[r9 + numDefine5];
              heapClassInst.heap8[r7 + numDefine6] = r10;
              r10 = heapClassInst.heapU8[r9 + numDefine4];
              heapClassInst.heap8[r7 + numDefine7] = r10;
              r10 = heapClassInst.heapU8[r9 + numDefine11];
              heapClassInst.heap8[r7 + numDefine8] = r10;
              r10 = heapClassInst.heapU8[r9 + numDefine10];
              heapClassInst.heap8[r7 + numDefine9] = r10;
              r10 = heapClassInst.heapU8[r9 + numDefine9];
              heapClassInst.heap8[r7 + numDefine10] = r10;
              r10 = heapClassInst.heapU8[r9 + numDefine8];
              heapClassInst.heap8[r7 + numDefine11] = r10;
              r10 = heapClassInst.heapU8[r9 + numDefine15];
              heapClassInst.heap8[r7 + numDefine12] = r10;
              r10 = heapClassInst.heapU8[r9 + numDefine14];
              heapClassInst.heap8[r7 + numDefine13] = r10;
              r10 = heapClassInst.heapU8[r9 + numDefine13];
              heapClassInst.heap8[r7 + numDefine14] = r10;
              r9 = heapClassInst.heapU8[r9 + numDefine12];
              heapClassInst.heap8[r7 + numDefine15] = r9;
              r7 = heapClassInst.heap32[r1 + numDefine24];
              r7 = (r7 - r2) | 0;
              r9 = heapClassInst.heap32[r6 + numDefine24];
              r10 = heapClassInst.heapU8[r7 + numDefine19];
              r9 = (r9 - r2) | 0;
              heapClassInst.heap8[r9 + numDefine16] = r10;
              r10 = heapClassInst.heapU8[r7 + numDefine18];
              heapClassInst.heap8[r9 + numDefine17] = r10;
              r10 = heapClassInst.heapU8[r7 + numDefine17];
              heapClassInst.heap8[r9 + numDefine18] = r10;
              r10 = heapClassInst.heapU8[r7 + numDefine16];
              heapClassInst.heap8[r9 + numDefine19] = r10;
              r10 = heapClassInst.heapU8[r7 + numDefine23];
              heapClassInst.heap8[r9 + numDefine20] = r10;
              r10 = heapClassInst.heapU8[r7 + numDefine22];
              heapClassInst.heap8[r9 + numDefine21] = r10;
              r10 = heapClassInst.heapU8[r7 + numDefine21];
              heapClassInst.heap8[r9 + numDefine22] = r10;
              r10 = heapClassInst.heapU8[r7 + numDefine20];
              heapClassInst.heap8[r9 + numDefine23] = r10;
              r10 = heapClassInst.heapU8[r7 + numDefine27];
              heapClassInst.heap8[r9 + numDefine24] = r10;
              r10 = heapClassInst.heapU8[r7 + numDefine26];
              heapClassInst.heap8[r9 + numDefine25] = r10;
              r10 = heapClassInst.heapU8[r7 + numDefine25];
              heapClassInst.heap8[r9 + numDefine26] = r10;
              r10 = heapClassInst.heapU8[r7 + numDefine24];
              heapClassInst.heap8[r9 + numDefine27] = r10;
              r10 = heapClassInst.heapU8[r7 + numDefine31];
              heapClassInst.heap8[r9 + numDefine28] = r10;
              r10 = heapClassInst.heapU8[r7 + numDefine30];
              heapClassInst.heap8[r9 + numDefine29] = r10;
              r10 = heapClassInst.heapU8[r7 + numDefine29];
              heapClassInst.heap8[r9 + numDefine30] = r10;
              r7 = heapClassInst.heapU8[r7 + numDefine28];
              heapClassInst.heap8[r9 + numDefine31] = r7;
              r7 = heapClassInst.heap32[r1 + numDefine24];
              r7 = (r7 - r2) | 0;
              r7 = r7 >> numDefine2;
              r7 = heapClassInst.heap32[r7 + numDefine8];
              r9 = r7 << numDefine8;
              r10 = r7 >>> numDefine8;
              r11 = heapClassInst.heap32[r6 + numDefine24];
              r12 = r7 << numDefine24;
              r9 = r9 & numDefine11680;
              r10 = r10 & numDefine65280;
              r7 = r7 >>> numDefine24;
              r11 = (r11 - r2) | 0;
              r9 = r12 | r9;
              r7 = r10 | r7;
              r10 = r11 >> numDefine2;
              r7 = r9 | r7;
              heapClassInst.heap32[r10 + numDefine8] = r7;
              r7 = heapClassInst.heap32[r1 + numDefine24];
              r7 = (r7 - r2) | 0;
              r7 = r7 >> numDefine2;
              r7 = heapClassInst.heap32[r7 + numDefine9];
              r9 = r7 << numDefine8;
              r10 = r7 >>> numDefine8;
              r11 = heapClassInst.heap32[r6 + numDefine24];
              r12 = r7 << numDefine24;
              r9 = r9 & numDefine11680;
              r10 = r10 & numDefine65280;
              r7 = r7 >>> numDefine24;
              r11 = (r11 - r2) | 0;
              r9 = r12 | r9;
              r7 = r10 | r7;
              r10 = r11 >> numDefine2;
              r7 = r9 | r7;
              heapClassInst.heap32[r10 + numDefine9] = r7;
              r7 = heapClassInst.heap32[r1 + numDefine24];
              r7 = (r7 - r2) | 0;
              r7 = r7 >> numDefine2;
              r7 = heapClassInst.heap32[r7 + numDefine10];
              r9 = r7 << numDefine8;
              r10 = r7 >>> numDefine8;
              r11 = heapClassInst.heap32[r6 + numDefine24];
              r12 = r7 << numDefine24;
              r9 = r9 & numDefine11680;
              r10 = r10 & numDefine65280;
              r7 = r7 >>> numDefine24;
              r2 = (r11 - r2) | 0;
              r9 = r12 | r9;
              r7 = r10 | r7;
              r2 = r2 >> numDefine2;
              r7 = r9 | r7;
              heapClassInst.heap32[r2 + numDefine10] = r7;
              if (r5 === r0) {
                break repeat9;
              } else {
                r7 = heapClassInst.heap32[r6 + numDefine24];
                r0 = (r0 + -1) | 0;
              }
            }
          }
        } else {
          if (r8 > 0) {
            r5 = (r5 - r8) | 0;
            r0 = 0;
            while (true) {
              r2 = r0 << numDefine6;
              r9 = heapClassInst.heap32[r1 + numDefine24];
              r7 = (r7 - r2) | 0;
              r9 = (r9 - r2) | 0;
              r7 = r7 >> numDefine2;
              r9 = r9 >> numDefine2;
              heapClassInst.heap32[r7] = heapClassInst.heap32[r9];
              heapClassInst.heap32[r7 + 1] = heapClassInst.heap32[r9 + 1];
              heapClassInst.heap32[r7 + numDefine2] = heapClassInst.heap32[r9 + numDefine2];
              heapClassInst.heap32[r7 + numDefine3] = heapClassInst.heap32[r9 + numDefine3];
              r7 = heapClassInst.heap32[r6 + numDefine24];
              r9 = heapClassInst.heap32[r1 + numDefine24];
              r7 = (r7 - r2) | 0;
              r9 = (r9 - r2) | 0;
              r7 = r7 >> numDefine2;
              r9 = r9 >> numDefine2;
              heapClassInst.heap32[r7 + numDefine4] = heapClassInst.heap32[r9 + numDefine4];
              heapClassInst.heap32[r7 + numDefine5] = heapClassInst.heap32[r9 + numDefine5];
              heapClassInst.heap32[r7 + numDefine6] = heapClassInst.heap32[r9 + numDefine6];
              heapClassInst.heap32[r7 + numDefine7] = heapClassInst.heap32[r9 + numDefine7];
              r7 = heapClassInst.heap32[r1 + numDefine24];
              r7 = (r7 - r2) | 0;
              r7 = r7 >> numDefine2;
              r9 = heapClassInst.heap32[r6 + numDefine24];
              r9 = (r9 - r2) | 0;
              r7 = heapClassInst.heap32[r7 + numDefine8];
              r9 = r9 >> numDefine2;
              heapClassInst.heap32[r9 + numDefine8] = r7;
              r7 = heapClassInst.heap32[r1 + numDefine24];
              r7 = (r7 - r2) | 0;
              r7 = r7 >> numDefine2;
              r9 = heapClassInst.heap32[r6 + numDefine24];
              r9 = (r9 - r2) | 0;
              r7 = heapClassInst.heap32[r7 + numDefine9];
              r9 = r9 >> numDefine2;
              heapClassInst.heap32[r9 + numDefine9] = r7;
              r7 = heapClassInst.heap32[r1 + numDefine24];
              r7 = (r7 - r2) | 0;
              r7 = r7 >> numDefine2;
              r9 = heapClassInst.heap32[r6 + numDefine24];
              r2 = (r9 - r2) | 0;
              r7 = heapClassInst.heap32[r7 + numDefine10];
              r2 = r2 >> numDefine2;
              heapClassInst.heap32[r2 + numDefine10] = r7;
              if (r5 === r0) {
                break repeat9;
              } else {
                r7 = heapClassInst.heap32[r6 + numDefine24];
                r0 = (r0 + -1) | 0;
              }
            }
          }
        }
      } while (false);
      r5 = heapClassInst.heap32[r6 + numDefine24];
      if (!(r5 === 0)) {
        r0 = heapClassInst.heapU8[r3 + numDefine100];
        if (!(r0 === 0)) {
          r0 = gNumAlignedFree;
          r0 = r0 >> numDefine2;
          r2 = heapClassInst.heap32[r0];
          r2 = (r2 + 1) | 0;
          r5 = r5 >> numDefine2;
          heapClassInst.heap32[r0] = r2;
          r5 = heapClassInst.heap32[r5 + -1];
          heapClassInst.heap32[g0] = r5;
          free(i7);
        }
        heapClassInst.heap32[r6 + numDefine24] = 0;
      }
      r5 = r8 << numDefine6;
      r0 = 0;
      heapClassInst.heap8[r3 + numDefine100] = r0;
      heapClassInst.heap32[r6 + numDefine24] = 0;
      heapClassInst.heap32[r6 + numDefine22] = 0;
      heapClassInst.heap32[r6 + numDefine23] = 0;
    } else {
      heapClassInst.heap8[r3 + numDefine140] = r2;
      heapClassInst.heap32[r6 + numDefine34] = r7;
      heapClassInst.heap32[r6 + numDefine32] = r8;
      heapClassInst.heap32[r6 + numDefine33] = r8;
      repeat28: do {
        if (r4 !== 0) {
          if (!(r8 < 1)) {
            r5 = (r5 - r8) | 0;
            while (true) {
              r0 = heapClassInst.heap32[r1 + numDefine34];
              r9 = r2 << numDefine4;
              r0 = (r0 - r9) | 0;
              r0 = heapClassInst.heapU16[r0 >> 1];
              r10 = r0 << numDefine8;
              r0 = r0 << numDefine24;
              r10 = r10 & numDefine11680;
              r0 = r0 | r10;
              r7 = (r7 - r9) | 0;
              r0 = r0 >>> numDefine16;
              heapClassInst.heap16[r7 >> 1] = r0;
              r7 = heapClassInst.heap32[r1 + numDefine34];
              r7 = (r7 - r9) | 0;
              r7 = heapClassInst.heapU16[(r7 + numDefine2) >> 1];
              r0 = r7 << numDefine8;
              r7 = r7 << numDefine24;
              r0 = r0 & numDefine11680;
              r10 = heapClassInst.heap32[r6 + numDefine34];
              r7 = r7 | r0;
              r0 = (r10 - r9) | 0;
              r7 = r7 >>> numDefine16;
              heapClassInst.heap16[(r0 + numDefine2) >> 1] = r7;
              r7 = heapClassInst.heap32[r1 + numDefine34];
              r7 = (r7 - r9) | 0;
              r7 = heapClassInst.heapU16[(r7 + numDefine4) >> 1];
              r0 = r7 << numDefine8;
              r7 = r7 << numDefine24;
              r0 = r0 & numDefine11680;
              r10 = heapClassInst.heap32[r6 + numDefine34];
              r7 = r7 | r0;
              r0 = (r10 - r9) | 0;
              r7 = r7 >>> numDefine16;
              heapClassInst.heap16[(r0 + numDefine4) >> 1] = r7;
              r7 = heapClassInst.heap32[r1 + numDefine34];
              r7 = (r7 - r9) | 0;
              r7 = heapClassInst.heapU16[(r7 + numDefine6) >> 1];
              r0 = r7 << numDefine8;
              r7 = r7 << numDefine24;
              r0 = r0 & numDefine11680;
              r10 = heapClassInst.heap32[r6 + numDefine34];
              r7 = r7 | r0;
              r0 = (r10 - r9) | 0;
              r7 = r7 >>> numDefine16;
              heapClassInst.heap16[(r0 + numDefine6) >> 1] = r7;
              r7 = heapClassInst.heap32[r1 + numDefine34];
              r7 = (r7 - r9) | 0;
              r7 = heapClassInst.heapU16[(r7 + numDefine8) >> 1];
              r0 = r7 << numDefine8;
              r7 = r7 << numDefine24;
              r0 = r0 & numDefine11680;
              r10 = heapClassInst.heap32[r6 + numDefine34];
              r7 = r7 | r0;
              r0 = (r10 - r9) | 0;
              r7 = r7 >>> numDefine16;
              heapClassInst.heap16[(r0 + numDefine8) >> 1] = r7;
              r7 = heapClassInst.heap32[r1 + numDefine34];
              r7 = (r7 - r9) | 0;
              r7 = heapClassInst.heapU16[(r7 + numDefine10) >> 1];
              r0 = r7 << numDefine8;
              r7 = r7 << numDefine24;
              r0 = r0 & numDefine11680;
              r10 = heapClassInst.heap32[r6 + numDefine34];
              r7 = r7 | r0;
              r0 = (r10 - r9) | 0;
              r7 = r7 >>> numDefine16;
              heapClassInst.heap16[(r0 + numDefine10) >> 1] = r7;
              r7 = heapClassInst.heap32[r1 + numDefine34];
              r7 = (r7 - r9) | 0;
              r7 = r7 >> numDefine2;
              r7 = heapClassInst.heap32[r7 + numDefine3];
              r0 = r7 << numDefine8;
              r10 = r7 >>> numDefine8;
              r11 = heapClassInst.heap32[r6 + numDefine34];
              r12 = r7 << numDefine24;
              r0 = r0 & numDefine11680;
              r10 = r10 & numDefine65280;
              r7 = r7 >>> numDefine24;
              r9 = (r11 - r9) | 0;
              r0 = r12 | r0;
              r7 = r10 | r7;
              r9 = r9 >> numDefine2;
              r7 = r0 | r7;
              heapClassInst.heap32[r9 + numDefine3] = r7;
              if (r5 === r2) {
                break repeat28;
              } else {
                r7 = heapClassInst.heap32[r6 + numDefine34];
                r2 = (r2 + -1) | 0;
              }
            }
          }
        } else {
          if (r8 > 0) {
            r5 = (r5 - r8) | 0;
            r0 = 0;
            while (true) {
              r2 = r0 << numDefine4;
              r9 = heapClassInst.heap32[r1 + numDefine34];
              r9 = (r9 - r2) | 0;
              r9 = heapClassInst.heapU16[r9 >> 1];
              r7 = (r7 - r2) | 0;
              heapClassInst.heap16[r7 >> 1] = r9;
              r7 = heapClassInst.heap32[r1 + numDefine34];
              r7 = (r7 - r2) | 0;
              r9 = heapClassInst.heap32[r6 + numDefine34];
              r7 = heapClassInst.heapU16[(r7 + numDefine2) >> 1];
              r9 = (r9 - r2) | 0;
              heapClassInst.heap16[(r9 + numDefine2) >> 1] = r7;
              r7 = heapClassInst.heap32[r1 + numDefine34];
              r7 = (r7 - r2) | 0;
              r9 = heapClassInst.heap32[r6 + numDefine34];
              r7 = heapClassInst.heapU16[(r7 + numDefine4) >> 1];
              r9 = (r9 - r2) | 0;
              heapClassInst.heap16[(r9 + numDefine4) >> 1] = r7;
              r7 = heapClassInst.heap32[r1 + numDefine34];
              r7 = (r7 - r2) | 0;
              r9 = heapClassInst.heap32[r6 + numDefine34];
              r7 = heapClassInst.heapU16[(r7 + numDefine6) >> 1];
              r9 = (r9 - r2) | 0;
              heapClassInst.heap16[(r9 + numDefine6) >> 1] = r7;
              r7 = heapClassInst.heap32[r1 + numDefine34];
              r7 = (r7 - r2) | 0;
              r9 = heapClassInst.heap32[r6 + numDefine34];
              r7 = heapClassInst.heapU16[(r7 + numDefine8) >> 1];
              r9 = (r9 - r2) | 0;
              heapClassInst.heap16[(r9 + numDefine8) >> 1] = r7;
              r7 = heapClassInst.heap32[r1 + numDefine34];
              r7 = (r7 - r2) | 0;
              r9 = heapClassInst.heap32[r6 + numDefine34];
              r7 = heapClassInst.heapU16[(r7 + numDefine10) >> 1];
              r9 = (r9 - r2) | 0;
              heapClassInst.heap16[(r9 + numDefine10) >> 1] = r7;
              r7 = heapClassInst.heap32[r1 + numDefine34];
              r7 = (r7 - r2) | 0;
              r7 = r7 >> numDefine2;
              r9 = heapClassInst.heap32[r6 + numDefine34];
              r2 = (r9 - r2) | 0;
              r7 = heapClassInst.heap32[r7 + numDefine3];
              r2 = r2 >> numDefine2;
              heapClassInst.heap32[r2 + numDefine3] = r7;
              if (r5 === r0) {
                break repeat28;
              } else {
                r7 = heapClassInst.heap32[r6 + numDefine34];
                r0 = (r0 + -1) | 0;
              }
            }
          }
        }
      } while (false);
      r5 = heapClassInst.heap32[r6 + numDefine34];
      if (!(r5 === 0)) {
        r7 = heapClassInst.heapU8[r3 + numDefine140];
        if (!(r7 === 0)) {
          r7 = gNumAlignedFree;
          r7 = r7 >> numDefine2;
          r0 = heapClassInst.heap32[r7];
          r0 = (r0 + 1) | 0;
          r5 = r5 >> numDefine2;
          heapClassInst.heap32[r7] = r0;
          r5 = heapClassInst.heap32[r5 + -1];
          heapClassInst.heap32[g0] = r5;
          free(i7);
        }
        heapClassInst.heap32[r6 + numDefine34] = 0;
      }
      r5 = r8 << numDefine4;
      r7 = 0;
      heapClassInst.heap8[r3 + numDefine140] = r7;
      heapClassInst.heap32[r6 + numDefine34] = 0;
      heapClassInst.heap32[r6 + numDefine32] = 0;
      heapClassInst.heap32[r6 + numDefine33] = 0;
    }
    r0 = heapClassInst.heap32[r6 + numDefine40];
    r2 = heapClassInst.heap32[r1 + numDefine42];
    if (!(r0 === 0)) {
      r7 = heapClassInst.heapU8[r3 + numDefine164];
      if (!(r7 === 0)) {
        r7 = gNumAlignedFree;
        r7 = r7 >> numDefine2;
        r8 = heapClassInst.heap32[r7];
        r8 = (r8 + 1) | 0;
        r0 = r0 >> numDefine2;
        heapClassInst.heap32[r7] = r8;
        r0 = heapClassInst.heap32[r0 + -1];
        heapClassInst.heap32[g0] = r0;
        free(i7);
      }
      heapClassInst.heap32[r6 + numDefine40] = 0;
    }
    r0 = (r5 + r3) | 0;
    r0 = (r0 + numDefine172) | 0;
    r5 = 0;
    heapClassInst.heap8[r3 + numDefine164] = r5;
    heapClassInst.heap32[r6 + numDefine40] = r0;
    heapClassInst.heap32[r6 + numDefine38] = r2;
    heapClassInst.heap32[r6 + numDefine39] = r2;
    r2 = heapClassInst.heap32[r1 + numDefine42];
    repeat53: do {
      if (r4 !== 0) {
        if (!(r2 < 1)) {
          label = numDefine41;
          while (true) {
            r2 = r5 << numDefine5;
            r4 = heapClassInst.heap32[r1 + numDefine40];
            r4 = heapClassInst.heapU16[(r4 + r2) >> 1];
            r7 = r4 << numDefine8;
            r4 = r4 << numDefine24;
            r7 = r7 & numDefine11680;
            r4 = r4 | r7;
            r4 = r4 >>> numDefine16;
            heapClassInst.heap16[(r0 + r2) >> 1] = r4;
            r0 = heapClassInst.heap32[r1 + numDefine40];
            r0 = (r0 + r2) | 0;
            r0 = heapClassInst.heapU16[(r0 + numDefine2) >> 1];
            r4 = r0 << numDefine8;
            r0 = r0 << numDefine24;
            r4 = r4 & numDefine11680;
            r7 = heapClassInst.heap32[r6 + numDefine40];
            r0 = r0 | r4;
            r4 = (r7 + r2) | 0;
            r0 = r0 >>> numDefine16;
            heapClassInst.heap16[(r4 + numDefine2) >> 1] = r0;
            r0 = heapClassInst.heap32[r1 + numDefine40];
            r0 = (r0 + r2) | 0;
            r0 = heapClassInst.heapU16[(r0 + numDefine4) >> 1];
            r4 = r0 << numDefine8;
            r0 = r0 << numDefine24;
            r4 = r4 & numDefine11680;
            r7 = heapClassInst.heap32[r6 + numDefine40];
            r0 = r0 | r4;
            r4 = (r7 + r2) | 0;
            r0 = r0 >>> numDefine16;
            heapClassInst.heap16[(r4 + numDefine4) >> 1] = r0;
            r0 = heapClassInst.heap32[r1 + numDefine40];
            r0 = (r0 + r2) | 0;
            r0 = heapClassInst.heapU16[(r0 + numDefine6) >> 1];
            r4 = r0 << numDefine8;
            r0 = r0 << numDefine24;
            r4 = r4 & numDefine11680;
            r7 = heapClassInst.heap32[r6 + numDefine40];
            r0 = r0 | r4;
            r4 = (r7 + r2) | 0;
            r0 = r0 >>> numDefine16;
            heapClassInst.heap16[(r4 + numDefine6) >> 1] = r0;
            r0 = heapClassInst.heap32[r1 + numDefine40];
            r0 = (r0 + r2) | 0;
            r0 = heapClassInst.heapU16[(r0 + numDefine8) >> 1];
            r4 = r0 << numDefine8;
            r0 = r0 << numDefine24;
            r4 = r4 & numDefine11680;
            r7 = heapClassInst.heap32[r6 + numDefine40];
            r0 = r0 | r4;
            r4 = (r7 + r2) | 0;
            r0 = r0 >>> numDefine16;
            heapClassInst.heap16[(r4 + numDefine8) >> 1] = r0;
            r0 = heapClassInst.heap32[r1 + numDefine40];
            r0 = (r0 + r2) | 0;
            r0 = heapClassInst.heapU16[(r0 + numDefine10) >> 1];
            r4 = r0 << numDefine8;
            r0 = r0 << numDefine24;
            r4 = r4 & numDefine11680;
            r7 = heapClassInst.heap32[r6 + numDefine40];
            r0 = r0 | r4;
            r4 = (r7 + r2) | 0;
            r0 = r0 >>> numDefine16;
            heapClassInst.heap16[(r4 + numDefine10) >> 1] = r0;
            r0 = heapClassInst.heap32[r1 + numDefine40];
            r0 = (r0 + r2) | 0;
            r0 = r0 >> numDefine2;
            r0 = heapClassInst.heap32[r0 + numDefine3];
            r4 = r0 << numDefine8;
            r7 = r0 >>> numDefine8;
            r8 = heapClassInst.heap32[r6 + numDefine40];
            r9 = r0 << numDefine24;
            r4 = r4 & numDefine11680;
            r7 = r7 & numDefine65280;
            r0 = r0 >>> numDefine24;
            r8 = (r8 + r2) | 0;
            r4 = r9 | r4;
            r0 = r7 | r0;
            r7 = r8 >> numDefine2;
            r0 = r4 | r0;
            heapClassInst.heap32[r7 + numDefine3] = r0;
            r0 = heapClassInst.heap32[r1 + numDefine40];
            r0 = (r0 + r2) | 0;
            r0 = r0 >> numDefine2;
            r0 = heapClassInst.heap32[r0 + numDefine4];
            r4 = r0 << numDefine8;
            r7 = r0 >>> numDefine8;
            r8 = heapClassInst.heap32[r6 + numDefine40];
            r9 = r0 << numDefine24;
            r4 = r4 & numDefine11680;
            r7 = r7 & numDefine65280;
            r0 = r0 >>> numDefine24;
            r2 = (r8 + r2) | 0;
            r4 = r9 | r4;
            r0 = r7 | r0;
            r5 = (r5 + 1) | 0;
            r2 = r2 >> numDefine2;
            r0 = r4 | r0;
            heapClassInst.heap32[r2 + numDefine4] = r0;
            r0 = heapClassInst.heap32[r1 + numDefine42];
            if (r0 <= r5) {
              break repeat53;
            } else {
              r0 = heapClassInst.heap32[r6 + numDefine40];
            }
          }
        }
      } else {
        if (r2 > 0) {
          r2 = 0;
          while (true) {
            r4 = r2 << numDefine5;
            r5 = heapClassInst.heap32[r1 + numDefine40];
            r5 = heapClassInst.heapU16[(r5 + r4) >> 1];
            heapClassInst.heap16[(r0 + r4) >> 1] = r5;
            r0 = heapClassInst.heap32[r1 + numDefine40];
            r0 = (r0 + r4) | 0;
            r5 = heapClassInst.heap32[r6 + numDefine40];
            r0 = heapClassInst.heapU16[(r0 + numDefine2) >> 1];
            r5 = (r5 + r4) | 0;
            heapClassInst.heap16[(r5 + numDefine2) >> 1] = r0;
            r0 = heapClassInst.heap32[r1 + numDefine40];
            r0 = (r0 + r4) | 0;
            r5 = heapClassInst.heap32[r6 + numDefine40];
            r0 = heapClassInst.heapU16[(r0 + numDefine4) >> 1];
            r5 = (r5 + r4) | 0;
            heapClassInst.heap16[(r5 + numDefine4) >> 1] = r0;
            r0 = heapClassInst.heap32[r1 + numDefine40];
            r0 = (r0 + r4) | 0;
            r5 = heapClassInst.heap32[r6 + numDefine40];
            r0 = heapClassInst.heapU16[(r0 + numDefine6) >> 1];
            r5 = (r5 + r4) | 0;
            heapClassInst.heap16[(r5 + numDefine6) >> 1] = r0;
            r0 = heapClassInst.heap32[r1 + numDefine40];
            r0 = (r0 + r4) | 0;
            r5 = heapClassInst.heap32[r6 + numDefine40];
            r0 = heapClassInst.heapU16[(r0 + numDefine8) >> 1];
            r5 = (r5 + r4) | 0;
            heapClassInst.heap16[(r5 + numDefine8) >> 1] = r0;
            r0 = heapClassInst.heap32[r1 + numDefine40];
            r0 = (r0 + r4) | 0;
            r5 = heapClassInst.heap32[r6 + numDefine40];
            r0 = heapClassInst.heapU16[(r0 + numDefine10) >> 1];
            r5 = (r5 + r4) | 0;
            heapClassInst.heap16[(r5 + numDefine10) >> 1] = r0;
            r0 = heapClassInst.heap32[r1 + numDefine40];
            r0 = (r0 + r4) | 0;
            r0 = r0 >> numDefine2;
            r5 = heapClassInst.heap32[r6 + numDefine40];
            r5 = (r5 + r4) | 0;
            r0 = heapClassInst.heap32[r0 + numDefine3];
            r5 = r5 >> numDefine2;
            heapClassInst.heap32[r5 + numDefine3] = r0;
            r0 = heapClassInst.heap32[r1 + numDefine40];
            r0 = (r0 + r4) | 0;
            r0 = r0 >> numDefine2;
            r5 = heapClassInst.heap32[r6 + numDefine40];
            r5 = (r5 + r4) | 0;
            r0 = heapClassInst.heap32[r0 + numDefine4];
            r5 = r5 >> numDefine2;
            heapClassInst.heap32[r5 + numDefine4] = r0;
            r0 = heapClassInst.heap32[r6 + numDefine40];
            r0 = (r0 + r4) | 0;
            r0 = r0 >> numDefine2;
            heapClassInst.heap32[r0 + numDefine5] = 0;
            r0 = heapClassInst.heap32[r6 + numDefine40];
            r0 = (r0 + r4) | 0;
            r0 = r0 >> numDefine2;
            heapClassInst.heap32[r0 + numDefine6] = 0;
            r0 = heapClassInst.heap32[r6 + numDefine40];
            r0 = (r0 + r4) | 0;
            r2 = (r2 + 1) | 0;
            r0 = r0 >> numDefine2;
            heapClassInst.heap32[r0 + numDefine7] = 0;
            r0 = heapClassInst.heap32[r1 + numDefine42];
            if (r0 <= r2) {
              break repeat53;
            } else {
              r0 = heapClassInst.heap32[r6 + numDefine40];
            }
          }
        }
      }
    } while (false);
    r0 = heapClassInst.heap32[r6 + numDefine40];
    if (!(r0 === 0)) {
      r1 = heapClassInst.heapU8[r3 + numDefine164];
      if (!(r1 === 0)) {
        r1 = gNumAlignedFree;
        r1 = r1 >> numDefine2;
        r2 = heapClassInst.heap32[r1];
        r2 = (r2 + 1) | 0;
        r0 = r0 >> numDefine2;
        heapClassInst.heap32[r1] = r2;
        r0 = heapClassInst.heap32[r0 + -1];
        heapClassInst.heap32[g0] = r0;
        free(i7);
      }
      heapClassInst.heap32[r6 + numDefine40] = 0;
    }
    r0 = 0;
    heapClassInst.heap8[r3 + numDefine164] = r0;
    heapClassInst.heap32[r6 + numDefine40] = 0;
    heapClassInst.heap32[r6 + numDefine38] = 0;
    heapClassInst.heap32[r6 + numDefine39] = 0;
    heapClassInst.heap32[r6] = 0;
    r0 = 1;
    commonVariable.rg0 = r0;
    return;
  } else {
    r0 = twoEStr638;
    r1 = twoEStr537;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r1;
    heapClassInst.heap32[g0 + numDefine2] = numDefine847;
    assertNew(i7);
  }
}

function z15btTransformAabbRK9btVector3S1FRK11btTransformRSS5(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let f12: number = 0.0;
  let f13: number = 0.0;
  let f14: number = 0.0;
  let f15: number = 0.0;
  let f16: number = 0.0;
  let f17: number = 0.0;
  let f18: number = 0.0;
  let f19: number = 0.0;
  let f20: number = 0.0;
  let f21: number = 0.0;
  let f22: number = 0.0;
  let f23: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r0 = r0 >> numDefine2;
  r1 = r1 >> numDefine2;
  f0 = heapClassInst.heapFloat[r0];
  f1 = heapClassInst.heapFloat[r1];
  if (f0 <= f1) {
    f2 = heapClassInst.heapFloat[r0 + 1];
    f3 = heapClassInst.heapFloat[r1 + 1];
    if (f2 <= f3) {
      f4 = heapClassInst.heapFloat[r0 + numDefine2];
      f5 = heapClassInst.heapFloat[r1 + numDefine2];
      if (f4 <= f5) {
        f6 = heapClassInst.heapFloat[fp + numDefine2];
        r0 = heapClassInst.heap32[fp + numDefine3];
        r1 = heapClassInst.heap32[fp + numDefine4];
        r2 = heapClassInst.heap32[fp + numDefine5];
        f7 = f1 - f0;
        f8 = numDefineFloat05;
        f9 = f3 - f2;
        f10 = f5 - f4;
        r0 = r0 >> numDefine2;
        f4 = f5 + f4;
        f2 = f3 + f2;
        f0 = f1 + f0;
        f1 = f7 * f8;
        f3 = f9 * f8;
        f5 = f10 * f8;
        f7 = heapClassInst.heapFloat[r0 + numDefine10];
        f1 = f1 + f6;
        f3 = f3 + f6;
        f5 = f5 + f6;
        f4 = f4 * f8;
        f2 = f2 * f8;
        f0 = f0 * f8;
        f6 = 0;
        if (f7 < f6) {
          f8 = -f7;
        } else {
          f8 = f7;
        }
        f9 = heapClassInst.heapFloat[r0 + numDefine9];
        if (f9 < f6) {
          f10 = -f9;
        } else {
          f10 = f9;
        }
        f11 = heapClassInst.heapFloat[r0 + numDefine8];
        if (f11 < f6) {
          f12 = -f11;
        } else {
          f12 = f11;
        }
        f13 = heapClassInst.heapFloat[r0 + numDefine6];
        if (f13 < f6) {
          f14 = -f13;
        } else {
          f14 = f13;
        }
        f15 = heapClassInst.heapFloat[r0 + numDefine5];
        if (f15 < f6) {
          f16 = -f15;
        } else {
          f16 = f15;
        }
        f17 = heapClassInst.heapFloat[r0 + numDefine4];
        if (f17 < f6) {
          f18 = -f17;
        } else {
          f18 = f17;
        }
        f19 = heapClassInst.heapFloat[r0 + numDefine2];
        if (f19 < f6) {
          f20 = -f19;
        } else {
          f20 = f19;
        }
        f21 = heapClassInst.heapFloat[r0 + 1];
        if (f21 < f6) {
          f22 = -f21;
        } else {
          f22 = f21;
        }
        f23 = heapClassInst.heapFloat[r0];
        if (f23 < f6) {
          f6 = -f23;
        } else {
          f6 = f23;
        }
        f23 = f23 * f0;
        f21 = f21 * f2;
        f17 = f17 * f0;
        f15 = f15 * f2;
        f21 = f23 + f21;
        f19 = f19 * f4;
        f6 = f6 * f1;
        f22 = f22 * f3;
        f0 = f11 * f0;
        f2 = f9 * f2;
        f9 = f17 + f15;
        f11 = f13 * f4;
        f13 = f18 * f1;
        f15 = f16 * f3;
        f16 = f21 + f19;
        f17 = heapClassInst.heapFloat[r0 + numDefine12];
        f6 = f6 + f22;
        f18 = f20 * f5;
        f0 = f0 + f2;
        f2 = f7 * f4;
        f1 = f12 * f1;
        f3 = f10 * f3;
        f4 = f9 + f11;
        f7 = heapClassInst.heapFloat[r0 + numDefine13];
        f9 = heapClassInst.heapFloat[r0 + numDefine14];
        f10 = f13 + f15;
        f11 = f14 * f5;
        f12 = f16 + f17;
        f6 = f6 + f18;
        f0 = f0 + f2;
        r0 = r1 >> numDefine2;
        f1 = f1 + f3;
        f2 = f8 * f5;
        f3 = f4 + f7;
        f4 = f10 + f11;
        f5 = f12 - f6;
        f0 = f0 + f9;
        f1 = f1 + f2;
        f2 = f3 - f4;
        heapClassInst.heapFloat[r0] = f5;
        f5 = f0 - f1;
        heapClassInst.heapFloat[r0 + 1] = f2;
        heapClassInst.heapFloat[r0 + numDefine2] = f5;
        r1 = r2 >> numDefine2;
        f2 = f12 + f6;
        heapClassInst.heap32[r0 + numDefine3] = 0;
        f3 = f3 + f4;
        heapClassInst.heapFloat[r1] = f2;
        f0 = f0 + f1;
        heapClassInst.heapFloat[r1 + 1] = f3;
        heapClassInst.heapFloat[r1 + numDefine2] = f0;
        heapClassInst.heap32[r1 + numDefine3] = 0;
        return;
      } else {
        r0 = twoEStr5104;
        r1 = twoEStr3102;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r1;
        heapClassInst.heap32[g0 + numDefine2] = numDefine199;
        assertNew(i7);
      }
    } else {
      r0 = twoEStr4103;
      r1 = twoEStr3102;
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r1;
      heapClassInst.heap32[g0 + numDefine2] = numDefine198;
      assertNew(i7);
    }
  } else {
    r0 = twoEStr2101;
    r1 = twoEStr3102;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r1;
    heapClassInst.heap32[g0 + numDefine2] = numDefine197;
    assertNew(i7);
  }
}

function zn14btQuantizedBvh9buildTreeEii(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let r16: number = 0;
  let r17: number = 0;
  let r18: number = 0;
  let r19: number = 0;
  let r20: number = 0;
  let r21: number = 0;
  let r22: number = 0;
  let r23: number = 0;
  let r24: number = 0;
  let r25: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let f12: number = 0.0;
  let f13: number = 0.0;
  let f14: number = 0.0;
  let f15: number = 0.0;
  let f16: number = 0.0;
  let f17: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg112;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heap32[fp + numDefine2];
  r2 = (r1 - r0) | 0;
  if (r2 > 0) {
    r3 = heapClassInst.heap32[fp];
    r4 = r3 >> numDefine2;
    r5 = heapClassInst.heap32[r4 + numDefine14];
    if (r2 !== 1) {
      repeat5: do {
        if (r0 < r1) {
          r6 = heapClassInst.heapU8[r3 + numDefine60];
          f1 = 0;
          r7 = r0;
          f2 = f1;
          f3 = f1;
          repeat7: while (true) {
            r8 = r6 & numDefine255;
            if (r8 === 0) {
              r9 = heapClassInst.heap32[r4 + numDefine19];
              r10 = r7 << numDefine6;
              r9 = (r9 + r10) | 0;
              r9 = r9 >> numDefine2;
              f0 = heapClassInst.heapFloat[r9];
              f5 = heapClassInst.heapFloat[r9 + 1];
              f8 = heapClassInst.heapFloat[r9 + numDefine2];
              f4 = heapClassInst.heapFloat[r9 + numDefine4];
              f6 = heapClassInst.heapFloat[r9 + numDefine5];
              f7 = heapClassInst.heapFloat[r9 + numDefine6];
            } else {
              r9 = heapClassInst.heap32[r4 + numDefine29];
              r10 = r7 << numDefine4;
              r11 = (r9 + r10) | 0;
              r9 = heapClassInst.heapU16[(r9 + r10) >> 1];
              r10 = heapClassInst.heapU16[(r11 + numDefine2) >> 1];
              r12 = heapClassInst.heapU16[(r11 + numDefine4) >> 1];
              r13 = heapClassInst.heapU16[(r11 + numDefine6) >> 1];
              r14 = heapClassInst.heapU16[(r11 + numDefine8) >> 1];
              r11 = heapClassInst.heapU16[(r11 + numDefine10) >> 1];
              f0 = uint(r9);
              f4 = heapClassInst.heapFloat[r4 + numDefine9];
              f5 = uint(r13);
              f6 = uint(r10);
              f7 = heapClassInst.heapFloat[r4 + numDefine10];
              f8 = uint(r14);
              f9 = uint(r12);
              f10 = heapClassInst.heapFloat[r4 + numDefine11];
              f11 = uint(r11);
              f0 = f0 / f4;
              f12 = heapClassInst.heapFloat[r4 + 1];
              f4 = f5 / f4;
              f5 = f6 / f7;
              f6 = heapClassInst.heapFloat[r4 + numDefine2];
              f7 = f8 / f7;
              f8 = f9 / f10;
              f9 = heapClassInst.heapFloat[r4 + numDefine3];
              f10 = f11 / f10;
              f0 = f0 + f12;
              f5 = f5 + f6;
              f8 = f8 + f9;
              f4 = f4 + f12;
              f6 = f7 + f6;
              f7 = f10 + f9;
            }
            f0 = f4 + f0;
            f4 = numDefineFloat05;
            f5 = f6 + f5;
            f6 = f7 + f8;
            f0 = f0 * f4;
            f5 = f5 * f4;
            f6 = f6 * f4;
            r7 = (r7 + 1) | 0;
            f3 = f3 + f0;
            f2 = f2 + f5;
            f1 = f1 + f6;
            if (!(r1 !== r7)) {
              break repeat7;
            }
          }
          f0 = r2;
          if (r0 < r1) {
            f5 = 1;
            f5 = f5 / f0;
            f6 = f3 * f5;
            f7 = f2 * f5;
            f5 = f1 * f5;
            f1 = 0;
            r6 = r0;
            f2 = f1;
            f3 = f1;
            while (true) {
              if (r8 === 0) {
                r7 = heapClassInst.heap32[r4 + numDefine19];
                r9 = r6 << numDefine6;
                r7 = (r7 + r9) | 0;
                r7 = r7 >> numDefine2;
                f8 = heapClassInst.heapFloat[r7];
                f10 = heapClassInst.heapFloat[r7 + 1];
                f13 = heapClassInst.heapFloat[r7 + numDefine2];
                f9 = heapClassInst.heapFloat[r7 + numDefine4];
                f11 = heapClassInst.heapFloat[r7 + numDefine5];
                f12 = heapClassInst.heapFloat[r7 + numDefine6];
              } else {
                r7 = heapClassInst.heap32[r4 + numDefine29];
                r9 = r6 << numDefine4;
                r10 = (r7 + r9) | 0;
                r7 = heapClassInst.heapU16[(r7 + r9) >> 1];
                r9 = heapClassInst.heapU16[(r10 + numDefine2) >> 1];
                r11 = heapClassInst.heapU16[(r10 + numDefine4) >> 1];
                r12 = heapClassInst.heapU16[(r10 + numDefine6) >> 1];
                r13 = heapClassInst.heapU16[(r10 + numDefine8) >> 1];
                r10 = heapClassInst.heapU16[(r10 + numDefine10) >> 1];
                f8 = uint(r7);
                f9 = heapClassInst.heapFloat[r4 + numDefine9];
                f10 = uint(r12);
                f11 = uint(r9);
                f12 = heapClassInst.heapFloat[r4 + numDefine10];
                f13 = uint(r13);
                f14 = uint(r11);
                f15 = heapClassInst.heapFloat[r4 + numDefine11];
                f16 = uint(r10);
                f8 = f8 / f9;
                f17 = heapClassInst.heapFloat[r4 + 1];
                f9 = f10 / f9;
                f10 = f11 / f12;
                f11 = heapClassInst.heapFloat[r4 + numDefine2];
                f12 = f13 / f12;
                f13 = f14 / f15;
                f14 = heapClassInst.heapFloat[r4 + numDefine3];
                f15 = f16 / f15;
                f8 = f8 + f17;
                f10 = f10 + f11;
                f13 = f13 + f14;
                f9 = f9 + f17;
                f11 = f12 + f11;
                f12 = f15 + f14;
              }
              f8 = f9 + f8;
              f9 = f11 + f10;
              f10 = f12 + f13;
              f8 = f8 * f4;
              f9 = f9 * f4;
              f10 = f10 * f4;
              f8 = f8 - f6;
              f9 = f9 - f7;
              f10 = f10 - f5;
              f8 = f8 * f8;
              f9 = f9 * f9;
              f10 = f10 * f10;
              r6 = (r6 + 1) | 0;
              f3 = f3 + f8;
              f2 = f2 + f9;
              f1 = f1 + f10;
              if (!(r1 !== r6)) {
                break repeat5;
              }
            }
          } else {
            f1 = 0;
            f2 = f1;
            f3 = f1;
          }
        } else {
          f0 = r2;
          f1 = 0;
          f2 = f1;
          f3 = f1;
        }
      } while (false);
      f4 = -1;
      f5 = 1;
      f0 = f0 + f4;
      f0 = f5 / f0;
      f3 = f3 * f0;
      f2 = f2 * f0;
      f0 = f1 * f0;
      if (f3 >= f2) {
        r6 = numDefine2;
        r7 = 0;
        r6 = f3 < f0 ? r6 : r7;
      } else {
        r6 = numDefine2;
        r7 = 1;
        r6 = f2 < f0 ? r6 : r7;
      }
      r7 = sp + numDefineNeg32;
      r8 = r7 >> numDefine2;
      heapClassInst.heap32[fp + numDefineNeg8] = 0;
      heapClassInst.heap32[r8 + 1] = 0;
      heapClassInst.heap32[r8 + numDefine2] = 0;
      heapClassInst.heap32[r8 + numDefine3] = 0;
      if (r0 < r1) {
        r9 = heapClassInst.heapU8[r3 + numDefine60];
        f0 = 0;
        r10 = r0;
        f1 = f0;
        f2 = f0;
        repeat31: while (true) {
          r11 = r9 & numDefine255;
          if (r11 === 0) {
            r11 = heapClassInst.heap32[r4 + numDefine19];
            r12 = r10 << numDefine6;
            r11 = (r11 + r12) | 0;
            r11 = r11 >> numDefine2;
            f3 = heapClassInst.heapFloat[r11];
            f6 = heapClassInst.heapFloat[r11 + 1];
            f9 = heapClassInst.heapFloat[r11 + numDefine2];
            f4 = heapClassInst.heapFloat[r11 + numDefine4];
            f7 = heapClassInst.heapFloat[r11 + numDefine5];
            f8 = heapClassInst.heapFloat[r11 + numDefine6];
          } else {
            r11 = heapClassInst.heap32[r4 + numDefine29];
            r12 = r10 << numDefine4;
            r13 = (r11 + r12) | 0;
            r11 = heapClassInst.heapU16[(r11 + r12) >> 1];
            r12 = heapClassInst.heapU16[(r13 + numDefine2) >> 1];
            r14 = heapClassInst.heapU16[(r13 + numDefine4) >> 1];
            r15 = heapClassInst.heapU16[(r13 + numDefine6) >> 1];
            r16 = heapClassInst.heapU16[(r13 + numDefine8) >> 1];
            r13 = heapClassInst.heapU16[(r13 + numDefine10) >> 1];
            f3 = uint(r11);
            f4 = heapClassInst.heapFloat[r4 + numDefine9];
            f6 = uint(r15);
            f7 = uint(r12);
            f8 = heapClassInst.heapFloat[r4 + numDefine10];
            f9 = uint(r16);
            f10 = uint(r14);
            f11 = heapClassInst.heapFloat[r4 + numDefine11];
            f12 = uint(r13);
            f3 = f3 / f4;
            f13 = heapClassInst.heapFloat[r4 + 1];
            f4 = f6 / f4;
            f6 = f7 / f8;
            f7 = heapClassInst.heapFloat[r4 + numDefine2];
            f8 = f9 / f8;
            f9 = f10 / f11;
            f10 = heapClassInst.heapFloat[r4 + numDefine3];
            f11 = f12 / f11;
            f3 = f3 + f13;
            f6 = f6 + f7;
            f9 = f9 + f10;
            f4 = f4 + f13;
            f7 = f8 + f7;
            f8 = f11 + f10;
          }
          f3 = f4 + f3;
          f4 = numDefineFloat05;
          f6 = f7 + f6;
          f7 = f8 + f9;
          f3 = f3 * f4;
          f6 = f6 * f4;
          f4 = f7 * f4;
          r10 = (r10 + 1) | 0;
          f2 = f2 + f3;
          f1 = f1 + f6;
          f0 = f0 + f4;
          if (!(r1 !== r10)) {
            break repeat31;
          }
        }
        heapClassInst.heapFloat[r8 + numDefine2] = f0;
        heapClassInst.heapFloat[r8 + 1] = f1;
        heapClassInst.heapFloat[fp + numDefineNeg8] = f2;
      } else {
        f0 = 0;
        f1 = f0;
        f2 = f0;
      }
      f3 = r2;
      f3 = f5 / f3;
      f2 = f2 * f3;
      f1 = f1 * f3;
      heapClassInst.heapFloat[fp + numDefineNeg8] = f2;
      f0 = f0 * f3;
      heapClassInst.heapFloat[r8 + 1] = f1;
      heapClassInst.heapFloat[r8 + numDefine2] = f0;
      repeat40: do {
        if (r0 < r1) {
          r8 = r6 << numDefine2;
          r6 = (r7 + r8) | 0;
          r6 = r6 >> numDefine2;
          f0 = heapClassInst.heapFloat[r6];
          r6 = r0 << numDefine4;
          r7 = (r0 - r1) | 0;
          r9 = r0 << numDefine6;
          r10 = r6 | numDefine12;
          r11 = 0;
          r12 = r9;
          r6 = r0;
          while (true) {
            r13 = heapClassInst.heapU8[r3 + numDefine60];
            if (r13 === 0) {
              r14 = r11 << numDefine4;
              r15 = heapClassInst.heap32[r4 + numDefine19];
              r15 = (r15 + r9) | 0;
              r14 = r14 << numDefine2;
              r14 = (r15 - r14) | 0;
              r14 = r14 >> numDefine2;
              f1 = heapClassInst.heapFloat[r14];
              f3 = heapClassInst.heapFloat[r14 + 1];
              f6 = heapClassInst.heapFloat[r14 + numDefine2];
              f2 = heapClassInst.heapFloat[r14 + numDefine4];
              f4 = heapClassInst.heapFloat[r14 + numDefine5];
              f5 = heapClassInst.heapFloat[r14 + numDefine6];
            } else {
              r14 = heapClassInst.heap32[r4 + numDefine29];
              r14 = (r14 + r10) | 0;
              r15 = r11 << numDefine4;
              r14 = (r14 - r15) | 0;
              r15 = heapClassInst.heapU16[(r14 + numDefineNeg12) >> 1];
              r16 = heapClassInst.heapU16[(r14 + numDefineNeg10) >> 1];
              r17 = heapClassInst.heapU16[(r14 + numDefineNeg8) >> 1];
              r18 = heapClassInst.heapU16[(r14 + numDefineNeg6) >> 1];
              r19 = heapClassInst.heapU16[(r14 + numDefineNeg4) >> 1];
              r14 = heapClassInst.heapU16[(r14 + numDefineNeg2) >> 1];
              f1 = uint(r15);
              f2 = heapClassInst.heapFloat[r4 + numDefine9];
              f3 = uint(r18);
              f4 = uint(r16);
              f5 = heapClassInst.heapFloat[r4 + numDefine10];
              f6 = uint(r19);
              f7 = uint(r17);
              f8 = heapClassInst.heapFloat[r4 + numDefine11];
              f9 = uint(r14);
              f1 = f1 / f2;
              f10 = heapClassInst.heapFloat[r4 + 1];
              f2 = f3 / f2;
              f3 = f4 / f5;
              f4 = heapClassInst.heapFloat[r4 + numDefine2];
              f5 = f6 / f5;
              f6 = f7 / f8;
              f7 = heapClassInst.heapFloat[r4 + numDefine3];
              f8 = f9 / f8;
              f1 = f1 + f10;
              f3 = f3 + f4;
              f6 = f6 + f7;
              f2 = f2 + f10;
              f4 = f5 + f4;
              f5 = f8 + f7;
            }
            f1 = f2 + f1;
            f2 = numDefineFloat05;
            r14 = sp + numDefineNeg48;
            f3 = f4 + f3;
            f1 = f1 * f2;
            f4 = f5 + f6;
            r15 = r14 >> numDefine2;
            f3 = f3 * f2;
            heapClassInst.heapFloat[fp + numDefineNeg12] = f1;
            f1 = f4 * f2;
            heapClassInst.heapFloat[r15 + 1] = f3;
            r14 = (r14 + r8) | 0;
            heapClassInst.heapFloat[r15 + numDefine2] = f1;
            r14 = r14 >> numDefine2;
            heapClassInst.heap32[r15 + numDefine3] = 0;
            f1 = heapClassInst.heapFloat[r14];
            if (f1 > f0) {
              if (r13 === 0) {
                r13 = r11 << numDefine4;
                r14 = heapClassInst.heap32[r4 + numDefine19];
                r15 = (r14 + r9) | 0;
                r13 = r13 << numDefine2;
                r13 = (r15 - r13) | 0;
                r13 = r13 >> numDefine2;
                r15 = heapClassInst.heap32[r13 + numDefine15];
                r16 = heapClassInst.heap32[r13 + numDefine14];
                r17 = heapClassInst.heap32[r13 + numDefine13];
                r18 = heapClassInst.heap32[r13 + numDefine12];
                r19 = heapClassInst.heap32[r13 + numDefine11];
                r20 = heapClassInst.heap32[r13 + numDefine10];
                r21 = heapClassInst.heap32[r13 + numDefine9];
                r22 = heapClassInst.heap32[r13 + numDefine8];
                f1 = heapClassInst.heapFloat[r13 + numDefine7];
                f2 = heapClassInst.heapFloat[r13 + numDefine6];
                f3 = heapClassInst.heapFloat[r13 + numDefine5];
                f4 = heapClassInst.heapFloat[r13 + numDefine4];
                f5 = heapClassInst.heapFloat[r13 + numDefine3];
                f6 = heapClassInst.heapFloat[r13 + numDefine2];
                f7 = heapClassInst.heapFloat[r13 + 1];
                f8 = heapClassInst.heapFloat[r13];
                r13 = r6 << numDefine6;
                r23 = (r14 + r12) | 0;
                r14 = (r14 + r13) | 0;
                heapClassInst.heap32[g0] = r23;
                heapClassInst.heap32[g0 + 1] = r14;
                heapClassInst.heap32[g0 + numDefine2] = numDefine64;
                memcpy(i7);
                r14 = heapClassInst.heap32[r4 + numDefine19];
                r13 = (r14 + r13) | 0;
                r13 = r13 >> numDefine2;
                heapClassInst.heapFloat[r13] = f8;
                heapClassInst.heapFloat[r13 + 1] = f7;
                heapClassInst.heapFloat[r13 + numDefine2] = f6;
                heapClassInst.heapFloat[r13 + numDefine3] = f5;
                heapClassInst.heapFloat[r13 + numDefine4] = f4;
                heapClassInst.heapFloat[r13 + numDefine5] = f3;
                heapClassInst.heapFloat[r13 + numDefine6] = f2;
                heapClassInst.heapFloat[r13 + numDefine7] = f1;
                heapClassInst.heap32[r13 + numDefine8] = r22;
                heapClassInst.heap32[r13 + numDefine9] = r21;
                heapClassInst.heap32[r13 + numDefine10] = r20;
                heapClassInst.heap32[r13 + numDefine11] = r19;
                heapClassInst.heap32[r13 + numDefine12] = r18;
                heapClassInst.heap32[r13 + numDefine13] = r17;
                heapClassInst.heap32[r13 + numDefine14] = r16;
                heapClassInst.heap32[r13 + numDefine15] = r15;
              } else {
                r13 = heapClassInst.heap32[r4 + numDefine29];
                r14 = (r13 + r10) | 0;
                r15 = r11 << numDefine4;
                r14 = (r14 - r15) | 0;
                r15 = r6 << numDefine4;
                r16 = r14 >> numDefine2;
                r17 = heapClassInst.heap32[r16];
                r18 = heapClassInst.heapU16[(r14 + numDefineNeg2) >> 1];
                r19 = heapClassInst.heapU16[(r14 + numDefineNeg4) >> 1];
                r20 = heapClassInst.heapU16[(r14 + numDefineNeg6) >> 1];
                r21 = heapClassInst.heapU16[(r14 + numDefineNeg8) >> 1];
                r22 = heapClassInst.heapU16[(r14 + numDefineNeg10) >> 1];
                r23 = heapClassInst.heapU16[(r13 + r15) >> 1];
                r24 = heapClassInst.heapU16[(r14 + numDefineNeg12) >> 1];
                r13 = (r13 + r15) | 0;
                heapClassInst.heap16[(r14 + numDefineNeg12) >> 1] = r23;
                r23 = heapClassInst.heapU16[(r13 + numDefine2) >> 1];
                heapClassInst.heap16[(r14 + numDefineNeg10) >> 1] = r23;
                r23 = heapClassInst.heapU16[(r13 + numDefine4) >> 1];
                heapClassInst.heap16[(r14 + numDefineNeg8) >> 1] = r23;
                r23 = heapClassInst.heapU16[(r13 + numDefine6) >> 1];
                heapClassInst.heap16[(r14 + numDefineNeg6) >> 1] = r23;
                r23 = heapClassInst.heapU16[(r13 + numDefine8) >> 1];
                heapClassInst.heap16[(r14 + numDefineNeg4) >> 1] = r23;
                r23 = heapClassInst.heapU16[(r13 + numDefine10) >> 1];
                r13 = r13 >> numDefine2;
                heapClassInst.heap16[(r14 + numDefineNeg2) >> 1] = r23;
                r13 = heapClassInst.heap32[r13 + numDefine3];
                heapClassInst.heap32[r16] = r13;
                r13 = heapClassInst.heap32[r4 + numDefine29];
                r14 = (r13 + r15) | 0;
                heapClassInst.heap16[(r13 + r15) >> 1] = r24;
                heapClassInst.heap16[(r14 + numDefine2) >> 1] = r22;
                heapClassInst.heap16[(r14 + numDefine4) >> 1] = r21;
                heapClassInst.heap16[(r14 + numDefine6) >> 1] = r20;
                heapClassInst.heap16[(r14 + numDefine8) >> 1] = r19;
                r13 = r14 >> numDefine2;
                heapClassInst.heap16[(r14 + numDefine10) >> 1] = r18;
                heapClassInst.heap32[r13 + numDefine3] = r17;
              }
              r6 = (r6 + 1) | 0;
            }
            r11 = (r11 + -1) | 0;
            r12 = (r12 + numDefine64) | 0;
            if (!(r7 !== r11)) {
              break repeat40;
            }
          }
        } else {
          r6 = r0;
        }
      } while (false);
      r7 = (r2 / numDefine3) | 0;
      r8 = (r7 + r0) | 0;
      if (r8 >= r6) {
        label = numDefine46;
      } else {
        r8 = (r1 + -1) | 0;
        r7 = (r8 - r7) | 0;
        if (r7 <= r6) {
          label = numDefine46;
        } else {
          label = numDefine47;
        }
      }
      if (label === numDefine46) {
        r6 = r2 >> 1;
        r6 = (r6 + r0) | 0;
      }
      if (!(r6 === r0)) {
        if (r6 !== r1) {
          r2 = heapClassInst.heap32[r4 + numDefine14];
          heapClassInst.heap32[fp + numDefineNeg21] = r2;
          r2 = heapClassInst.heapU8[r3 + numDefine60];
          if (r2 === 0) {
            r2 = heapClassInst.heap32[fp + numDefineNeg21];
            r2 = r2 << numDefine6;
            r7 = heapClassInst.heap32[r4 + numDefine24];
            r2 = (r7 + r2) | 0;
            r2 = r2 >> numDefine2;
            heapClassInst.heap32[r2] = heapClassInst.heap32[r4 + numDefine5];
            heapClassInst.heap32[r2 + 1] = heapClassInst.heap32[r4 + numDefine6];
            heapClassInst.heap32[r2 + numDefine2] = heapClassInst.heap32[r4 + numDefine2];
            heapClassInst.heap32[r2 + numDefine3] = heapClassInst.heap32[r4 + numDefine3];
          } else {
            r2 = heapClassInst.heap32[r4 + numDefine34];
            r7 = heapClassInst.heap32[fp + numDefineNeg21];
            r7 = r7 << numDefine4;
            r2 = (r2 + r7) | 0;
            r7 = (r3 + numDefine20) | 0;
            heapClassInst.heap32[g0] = r3;
            heapClassInst.heap32[g0 + 1] = r2;
            heapClassInst.heap32[g0 + numDefine2] = r7;
            heapClassInst.heap32[g0 + numDefine3] = 0;
            znk14btQuantizedBvh8quantizeEPtRK9btVector3i(i7);
          }
          r2 = heapClassInst.heap32[r4 + numDefine14];
          r7 = heapClassInst.heapU8[r3 + numDefine60];
          if (r7 === 0) {
            r2 = r2 << numDefine6;
            r7 = heapClassInst.heap32[r4 + numDefine24];
            r2 = (r7 + r2) | 0;
            r2 = r2 >> numDefine2;
            heapClassInst.heap32[r2 + numDefine4] = heapClassInst.heap32[r4 + 1];
            heapClassInst.heap32[r2 + numDefine5] = heapClassInst.heap32[r4 + numDefine5];
            heapClassInst.heap32[r2 + numDefine6] = heapClassInst.heap32[r4 + numDefine6];
            heapClassInst.heap32[r2 + numDefine7] = heapClassInst.heap32[r4 + numDefine7];
          } else {
            r7 = heapClassInst.heap32[r4 + numDefine34];
            r2 = r2 << numDefine4;
            r2 = (r7 + r2) | 0;
            r2 = (r2 + numDefine6) | 0;
            r7 = (r3 + numDefine4) | 0;
            heapClassInst.heap32[g0] = r3;
            heapClassInst.heap32[g0 + 1] = r2;
            heapClassInst.heap32[g0 + numDefine2] = r7;
            heapClassInst.heap32[g0 + numDefine3] = 1;
            znk14btQuantizedBvh8quantizeEPtRK9btVector3i(i7);
          }
          repeat73: do {
            if (!(r0 >= r1)) {
              r2 = r0;
              while (true) {
                r7 = heapClassInst.heapU8[r3 + numDefine60];
                repeat77: do {
                  if (r7 === 0) {
                    r7 = heapClassInst.heap32[r4 + numDefine19];
                    r8 = r2 << numDefine6;
                    r7 = (r7 + r8) | 0;
                    r7 = r7 >> numDefine2;
                    f0 = heapClassInst.heapFloat[r7 + numDefine4];
                    r8 = sp + numDefineNeg80;
                    heapClassInst.heapFloat[fp + numDefineNeg20] = f0;
                    f1 = heapClassInst.heapFloat[r7 + numDefine5];
                    r8 = r8 >> numDefine2;
                    heapClassInst.heapFloat[r8 + 1] = f1;
                    f2 = heapClassInst.heapFloat[r7 + numDefine6];
                    heapClassInst.heapFloat[r8 + numDefine2] = f2;
                    f3 = heapClassInst.heapFloat[r7 + numDefine7];
                    heapClassInst.heapFloat[r8 + numDefine3] = f3;
                    f4 = heapClassInst.heapFloat[r7];
                    r8 = sp + numDefineNeg64;
                    heapClassInst.heapFloat[fp + numDefineNeg16] = f4;
                    f5 = heapClassInst.heapFloat[r7 + 1];
                    r8 = r8 >> numDefine2;
                    heapClassInst.heapFloat[r8 + 1] = f5;
                    f6 = heapClassInst.heapFloat[r7 + numDefine2];
                    heapClassInst.heapFloat[r8 + numDefine2] = f6;
                    f7 = heapClassInst.heapFloat[r7 + numDefine3];
                    heapClassInst.heapFloat[r8 + numDefine3] = f7;
                    r7 = heapClassInst.heap32[r4 + numDefine14];
                    r8 = heapClassInst.heap32[r4 + numDefine24];
                    r7 = r7 << numDefine6;
                    r8 = (r8 + r7) | 0;
                    r8 = r8 >> numDefine2;
                    f8 = heapClassInst.heapFloat[r8];
                    if (!(f4 >= f8)) {
                      heapClassInst.heapFloat[r8] = f4;
                    }
                    f4 = heapClassInst.heapFloat[r8 + 1];
                    if (!(f5 >= f4)) {
                      heapClassInst.heapFloat[r8 + 1] = f5;
                    }
                    f4 = heapClassInst.heapFloat[r8 + numDefine2];
                    if (!(f6 >= f4)) {
                      heapClassInst.heapFloat[r8 + numDefine2] = f6;
                    }
                    f4 = heapClassInst.heapFloat[r8 + numDefine3];
                    if (!(f7 >= f4)) {
                      heapClassInst.heapFloat[r8 + numDefine3] = f7;
                    }
                    r8 = heapClassInst.heap32[r4 + numDefine24];
                    r7 = (r8 + r7) | 0;
                    r7 = r7 >> numDefine2;
                    f4 = heapClassInst.heapFloat[r7 + numDefine4];
                    if (!(f4 >= f0)) {
                      heapClassInst.heapFloat[r7 + numDefine4] = f0;
                    }
                    f0 = heapClassInst.heapFloat[r7 + numDefine5];
                    if (!(f0 >= f1)) {
                      heapClassInst.heapFloat[r7 + numDefine5] = f1;
                    }
                    f0 = heapClassInst.heapFloat[r7 + numDefine6];
                    if (!(f0 >= f2)) {
                      heapClassInst.heapFloat[r7 + numDefine6] = f2;
                    }
                    f0 = heapClassInst.heapFloat[r7 + numDefine7];
                    if (f0 >= f3) {
                      break repeat77;
                    } else {
                      heapClassInst.heapFloat[r7 + numDefine7] = f3;
                    }
                  } else {
                    r7 = heapClassInst.heap32[r4 + numDefine29];
                    r8 = r2 << numDefine4;
                    r9 = (r7 + r8) | 0;
                    r10 = sp + numDefineNeg80;
                    r11 = heapClassInst.heapU16[(r9 + numDefine10) >> 1];
                    r12 = heapClassInst.heapU16[(r9 + numDefine8) >> 1];
                    r13 = heapClassInst.heapU16[(r9 + numDefine6) >> 1];
                    f0 = heapClassInst.heapFloat[r4 + numDefine11];
                    f1 = heapClassInst.heapFloat[r4 + numDefine10];
                    f2 = heapClassInst.heapFloat[r4 + numDefine9];
                    r14 = r10 >> numDefine2;
                    f3 = uint(r13);
                    heapClassInst.heap32[r14 + numDefine3] = 0;
                    f3 = f3 / f2;
                    f4 = heapClassInst.heapFloat[r4 + 1];
                    f3 = f3 + f4;
                    f5 = uint(r12);
                    heapClassInst.heapFloat[fp + numDefineNeg20] = f3;
                    f3 = f5 / f1;
                    f5 = heapClassInst.heapFloat[r4 + numDefine2];
                    f3 = f3 + f5;
                    f6 = uint(r11);
                    heapClassInst.heapFloat[r14 + 1] = f3;
                    f3 = f6 / f0;
                    f6 = heapClassInst.heapFloat[r4 + numDefine3];
                    f3 = f3 + f6;
                    heapClassInst.heapFloat[r14 + numDefine2] = f3;
                    r7 = heapClassInst.heapU16[(r7 + r8) >> 1];
                    r8 = sp + numDefineNeg64;
                    f3 = uint(r7);
                    r7 = heapClassInst.heapU16[(r9 + numDefine4) >> 1];
                    r9 = heapClassInst.heapU16[(r9 + numDefine2) >> 1];
                    f7 = uint(r9);
                    f2 = f3 / f2;
                    r9 = r8 >> numDefine2;
                    f3 = uint(r7);
                    f1 = f7 / f1;
                    f2 = f2 + f4;
                    heapClassInst.heap32[r9 + numDefine3] = 0;
                    f0 = f3 / f0;
                    f1 = f1 + f5;
                    heapClassInst.heapFloat[fp + numDefineNeg16] = f2;
                    f0 = f0 + f6;
                    heapClassInst.heapFloat[r9 + 1] = f1;
                    heapClassInst.heapFloat[r9 + numDefine2] = f0;
                    r7 = heapClassInst.heap32[r4 + numDefine14];
                    r9 = sp + numDefineNeg6;
                    heapClassInst.heap32[g0] = r3;
                    heapClassInst.heap32[g0 + 1] = r9;
                    heapClassInst.heap32[g0 + numDefine2] = r8;
                    heapClassInst.heap32[g0 + numDefine3] = 0;
                    znk14btQuantizedBvh8quantizeEPtRK9btVector3i(i7);
                    r8 = sp + numDefineNeg12;
                    heapClassInst.heap32[g0] = r3;
                    heapClassInst.heap32[g0 + 1] = r8;
                    heapClassInst.heap32[g0 + numDefine2] = r10;
                    heapClassInst.heap32[g0 + numDefine3] = 1;
                    znk14btQuantizedBvh8quantizeEPtRK9btVector3i(i7);
                    r8 = heapClassInst.heapU16[(sp + numDefineNeg6) >> 1];
                    r9 = heapClassInst.heap32[r4 + numDefine34];
                    r7 = r7 << numDefine4;
                    r10 = heapClassInst.heapU16[(r9 + r7) >> 1];
                    if (uint(r10) > uint(r8)) {
                      heapClassInst.heap16[(r9 + r7) >> 1] = r8;
                      r9 = heapClassInst.heap32[r4 + numDefine34];
                    }
                    r8 = (r9 + r7) | 0;
                    r10 = heapClassInst.heapU16[(sp + numDefineNeg12) >> 1];
                    r11 = heapClassInst.heapU16[(r8 + numDefine6) >> 1];
                    if (uint(r11) < uint(r10)) {
                      heapClassInst.heap16[(r8 + numDefine6) >> 1] = r10;
                      r9 = heapClassInst.heap32[r4 + numDefine34];
                    }
                    r8 = (r9 + r7) | 0;
                    r10 = heapClassInst.heapU16[(sp + numDefineNeg4) >> 1];
                    r11 = heapClassInst.heapU16[(r8 + numDefine2) >> 1];
                    if (uint(r11) > uint(r10)) {
                      heapClassInst.heap16[(r8 + numDefine2) >> 1] = r10;
                      r9 = heapClassInst.heap32[r4 + numDefine34];
                    }
                    r8 = (r9 + r7) | 0;
                    r10 = heapClassInst.heapU16[(sp + numDefineNeg10) >> 1];
                    r11 = heapClassInst.heapU16[(r8 + numDefine8) >> 1];
                    if (uint(r11) < uint(r10)) {
                      heapClassInst.heap16[(r8 + numDefine8) >> 1] = r10;
                      r9 = heapClassInst.heap32[r4 + numDefine34];
                    }
                    r8 = (r9 + r7) | 0;
                    r10 = heapClassInst.heapU16[(sp + numDefineNeg2) >> 1];
                    r11 = heapClassInst.heapU16[(r8 + numDefine4) >> 1];
                    if (uint(r11) > uint(r10)) {
                      heapClassInst.heap16[(r8 + numDefine4) >> 1] = r10;
                      r9 = heapClassInst.heap32[r4 + numDefine34];
                    }
                    r7 = (r9 + r7) | 0;
                    r8 = heapClassInst.heapU16[(sp + numDefineNeg8) >> 1];
                    r9 = heapClassInst.heapU16[(r7 + numDefine10) >> 1];
                    if (uint(r9) < uint(r8)) {
                      heapClassInst.heap16[(r7 + numDefine10) >> 1] = r8;
                    }
                  }
                } while (false);
                r2 = (r2 + 1) | 0;
                if (!(r1 !== r2)) {
                  break repeat73;
                }
              }
            }
          } while (false);
          r2 = heapClassInst.heap32[r4 + numDefine14];
          r7 = (r2 + 1) | 0;
          heapClassInst.heap32[r4 + numDefine14] = r7;
          heapClassInst.heap32[g0] = r3;
          heapClassInst.heap32[g0 + 1] = r0;
          heapClassInst.heap32[g0 + numDefine2] = r6;
          zn14btQuantizedBvh9buildTreeEii(i7);
          r0 = heapClassInst.heap32[r4 + numDefine14];
          heapClassInst.heap32[fp + numDefineNeg23] = r0;
          heapClassInst.heap32[g0] = r3;
          heapClassInst.heap32[g0 + 1] = r6;
          heapClassInst.heap32[g0 + numDefine2] = r1;
          zn14btQuantizedBvh9buildTreeEii(i7);
          r0 = heapClassInst.heap32[r4 + numDefine14];
          r0 = (r0 - r5) | 0;
          heapClassInst.heap32[fp + numDefineNeg22] = r0;
          r0 = heapClassInst.heapU8[r3 + numDefine60];
          repeat120: do {
            if (!(r0 === 0)) {
              r0 = heapClassInst.heap32[fp + numDefineNeg22];
              r0 = r0 << numDefine4;
              if (!(r0 < numDefine2049)) {
                r0 = heapClassInst.heap32[r4 + numDefine34];
                r1 = heapClassInst.heap32[fp + numDefineNeg23];
                r1 = r1 << numDefine4;
                heapClassInst.heap32[fp + numDefineNeg24] = r1;
                r2 = r2 << numDefine4;
                r1 = (r0 + r1) | 0;
                r2 = (r0 + r2) | 0;
                r5 = r1 >> numDefine2;
                r6 = r2 >> numDefine2;
                r5 = heapClassInst.heap32[r5 + numDefine3];
                r8 = 0;
                r6 = heapClassInst.heap32[r6 + numDefine7];
                r9 = 1;
                r10 = (r8 - r6) | 0;
                r6 = r6 < 0 ? r10 : r9;
                r10 = r6 << numDefine4;
                if (!(r10 > numDefine2048)) {
                  r10 = heapClassInst.heap32[r4 + numDefine39];
                  r11 = heapClassInst.heap32[r4 + numDefine38];
                  if (r10 === r11) {
                    r12 = r11 << 1;
                    r12 = r11 === 0 ? r9 : r12;
                    if (r10 >= r12) {
                      label = numDefine92;
                    } else {
                      if (r12 !== 0) {
                        r10 = gNumAlignedAllocs;
                        r10 = r10 >> numDefine2;
                        r13 = heapClassInst.heap32[r10];
                        r13 = (r13 + 1) | 0;
                        r14 = r12 << numDefine5;
                        heapClassInst.heap32[r10] = r13;
                        r10 = r14 | numDefine19;
                        heapClassInst.heap32[g0] = r10;
                        mallocNew(i7);
                        r13 = commonVariable.rg0;
                        if (r13 !== 0) {
                          r10 = 0;
                          r14 = (r13 + numDefine4) | 0;
                          r10 = (r10 - r14) | 0;
                          r10 = r10 & numDefine15;
                          r10 = (r13 + r10) | 0;
                          r14 = (r10 + numDefine4) | 0;
                          r10 = r10 >> numDefine2;
                          heapClassInst.heap32[r10] = r13;
                          r13 = r14;
                        }
                      } else {
                        r13 = 0;
                      }
                      r14 = (r3 + numDefine160) | 0;
                      if (r11 < 1) {
                        r10 = r14 >> numDefine2;
                        r16 = heapClassInst.heap32[r10];
                      } else {
                        r10 = 0;
                        r15 = r11;
                        repeat137: while (true) {
                          r16 = r14 >> numDefine2;
                          r16 = heapClassInst.heap32[r16];
                          r17 = (r16 + r10) | 0;
                          r17 = r17 >> numDefine2;
                          r18 = (r13 + r10) | 0;
                          r15 = (r15 + -1) | 0;
                          r10 = (r10 + numDefine32) | 0;
                          r19 = heapClassInst.heap32[r17];
                          r18 = r18 >> numDefine2;
                          r20 = heapClassInst.heap32[r17 + 1];
                          r21 = heapClassInst.heap32[r17 + numDefine2];
                          r22 = heapClassInst.heap32[r17 + numDefine3];
                          r23 = heapClassInst.heap32[r17 + numDefine4];
                          r24 = heapClassInst.heap32[r17 + numDefine5];
                          r25 = heapClassInst.heap32[r17 + numDefine6];
                          r17 = heapClassInst.heap32[r17 + numDefine7];
                          heapClassInst.heap32[r18] = r19;
                          heapClassInst.heap32[r18 + 1] = r20;
                          heapClassInst.heap32[r18 + numDefine2] = r21;
                          heapClassInst.heap32[r18 + numDefine3] = r22;
                          heapClassInst.heap32[r18 + numDefine4] = r23;
                          heapClassInst.heap32[r18 + numDefine5] = r24;
                          heapClassInst.heap32[r18 + numDefine6] = r25;
                          heapClassInst.heap32[r18 + numDefine7] = r17;
                          if (!(r15 !== 0)) {
                            break repeat137;
                          }
                        }
                        r14 = (r3 + numDefine160) | 0;
                      }
                      if (r16 !== 0) {
                        r10 = heapClassInst.heapU8[r3 + numDefine164];
                        if (r10 !== 0) {
                          r10 = gNumAlignedFree;
                          r10 = r10 >> numDefine2;
                          r15 = heapClassInst.heap32[r10];
                          r15 = (r15 + 1) | 0;
                          r16 = r16 >> numDefine2;
                          heapClassInst.heap32[r10] = r15;
                          r10 = heapClassInst.heap32[r16 + -1];
                          heapClassInst.heap32[g0] = r10;
                          free(i7);
                          r10 = heapClassInst.heap32[r4 + numDefine38];
                        } else {
                          r10 = r11;
                        }
                        r15 = r14 >> numDefine2;
                        heapClassInst.heap32[r15] = 0;
                      } else {
                        r10 = r11;
                      }
                      r14 = r14 >> numDefine2;
                      heapClassInst.heap8[r3 + numDefine164] = r9;
                      heapClassInst.heap32[r14] = r13;
                      heapClassInst.heap32[r4 + numDefine39] = r12;
                      label = numDefine110;
                    }
                  } else {
                    label = numDefine92;
                  }
                  if (label === numDefine92) {
                    r10 = r11;
                  }
                  r10 = (r10 + 1) | 0;
                  heapClassInst.heap32[r4 + numDefine38] = r10;
                  r10 = heapClassInst.heap32[r4 + numDefine40];
                  r12 = heapClassInst.heapU16[(r2 + numDefine16) >> 1];
                  r11 = r11 << numDefine5;
                  heapClassInst.heap16[(r10 + r11) >> 1] = r12;
                  r10 = (r10 + r11) | 0;
                  r11 = heapClassInst.heapU16[(r2 + numDefine18) >> 1];
                  heapClassInst.heap16[(r10 + numDefine2) >> 1] = r11;
                  r11 = heapClassInst.heapU16[(r2 + numDefine20) >> 1];
                  heapClassInst.heap16[(r10 + numDefine4) >> 1] = r11;
                  r11 = heapClassInst.heapU16[(r2 + numDefine22) >> 1];
                  heapClassInst.heap16[(r10 + numDefine6) >> 1] = r11;
                  r11 = heapClassInst.heapU16[(r2 + numDefine24) >> 1];
                  heapClassInst.heap16[(r10 + numDefine8) >> 1] = r11;
                  r2 = heapClassInst.heapU16[(r2 + numDefine26) >> 1];
                  r11 = r10 >> numDefine2;
                  heapClassInst.heap16[(r10 + numDefine10) >> 1] = r2;
                  heapClassInst.heap32[r11 + numDefine3] = r7;
                  heapClassInst.heap32[r11 + numDefine4] = r6;
                }
                r2 = (r8 - r5) | 0;
                r2 = r5 < 0 ? r2 : r9;
                r5 = r2 << numDefine4;
                if (!(r5 > numDefine2048)) {
                  r5 = heapClassInst.heap32[r4 + numDefine39];
                  r6 = heapClassInst.heap32[r4 + numDefine38];
                  if (r5 === r6) {
                    r7 = r6 << 1;
                    r7 = r6 === 0 ? r9 : r7;
                    if (r5 >= r7) {
                      label = numDefine113;
                    } else {
                      if (r7 !== 0) {
                        r5 = gNumAlignedAllocs;
                        r5 = r5 >> numDefine2;
                        r10 = heapClassInst.heap32[r5];
                        r10 = (r10 + 1) | 0;
                        r11 = r7 << numDefine5;
                        heapClassInst.heap32[r5] = r10;
                        r5 = r11 | numDefine19;
                        heapClassInst.heap32[g0] = r5;
                        mallocNew(i7);
                        r10 = commonVariable.rg0;
                        if (r10 !== 0) {
                          r5 = (r10 + numDefine4) | 0;
                          r5 = (r8 - r5) | 0;
                          r5 = r5 & numDefine15;
                          r5 = (r10 + r5) | 0;
                          r11 = (r5 + numDefine4) | 0;
                          r5 = r5 >> numDefine2;
                          heapClassInst.heap32[r5] = r10;
                          r10 = r11;
                        }
                      } else {
                        r10 = 0;
                      }
                      r11 = (r3 + numDefine160) | 0;
                      if (r6 < 1) {
                        r5 = r11 >> numDefine2;
                        r12 = heapClassInst.heap32[r5];
                      } else {
                        r5 = r6;
                        repeat166: while (true) {
                          r12 = r11 >> numDefine2;
                          r12 = heapClassInst.heap32[r12];
                          r13 = (r12 + r8) | 0;
                          r13 = r13 >> numDefine2;
                          r14 = (r10 + r8) | 0;
                          r5 = (r5 + -1) | 0;
                          r8 = (r8 + numDefine32) | 0;
                          r15 = heapClassInst.heap32[r13];
                          r14 = r14 >> numDefine2;
                          r16 = heapClassInst.heap32[r13 + 1];
                          r17 = heapClassInst.heap32[r13 + numDefine2];
                          r18 = heapClassInst.heap32[r13 + numDefine3];
                          r19 = heapClassInst.heap32[r13 + numDefine4];
                          r20 = heapClassInst.heap32[r13 + numDefine5];
                          r21 = heapClassInst.heap32[r13 + numDefine6];
                          r13 = heapClassInst.heap32[r13 + numDefine7];
                          heapClassInst.heap32[r14] = r15;
                          heapClassInst.heap32[r14 + 1] = r16;
                          heapClassInst.heap32[r14 + numDefine2] = r17;
                          heapClassInst.heap32[r14 + numDefine3] = r18;
                          heapClassInst.heap32[r14 + numDefine4] = r19;
                          heapClassInst.heap32[r14 + numDefine5] = r20;
                          heapClassInst.heap32[r14 + numDefine6] = r21;
                          heapClassInst.heap32[r14 + numDefine7] = r13;
                          if (!(r5 !== 0)) {
                            break repeat166;
                          }
                        }
                        r11 = (r3 + numDefine160) | 0;
                      }
                      if (r12 !== 0) {
                        r5 = heapClassInst.heapU8[r3 + numDefine164];
                        if (r5 !== 0) {
                          r5 = gNumAlignedFree;
                          r5 = r5 >> numDefine2;
                          r8 = heapClassInst.heap32[r5];
                          r8 = (r8 + 1) | 0;
                          r12 = r12 >> numDefine2;
                          heapClassInst.heap32[r5] = r8;
                          r5 = heapClassInst.heap32[r12 + -1];
                          heapClassInst.heap32[g0] = r5;
                          free(i7);
                          r5 = heapClassInst.heap32[r4 + numDefine38];
                        } else {
                          r5 = r6;
                        }
                        r8 = r11 >> numDefine2;
                        heapClassInst.heap32[r8] = 0;
                      } else {
                        r5 = r6;
                      }
                      r8 = r11 >> numDefine2;
                      heapClassInst.heap8[r3 + numDefine164] = r9;
                      heapClassInst.heap32[r8] = r10;
                      heapClassInst.heap32[r4 + numDefine39] = r7;
                      label = numDefine131;
                    }
                  } else {
                    label = numDefine113;
                  }
                  if (label === numDefine113) {
                    r5 = r6;
                  }
                  r5 = (r5 + 1) | 0;
                  heapClassInst.heap32[r4 + numDefine38] = r5;
                  r5 = heapClassInst.heap32[r4 + numDefine40];
                  r7 = heapClassInst.heap32[fp + numDefineNeg24];
                  r0 = heapClassInst.heapU16[(r0 + r7) >> 1];
                  r6 = r6 << numDefine5;
                  heapClassInst.heap16[(r5 + r6) >> 1] = r0;
                  r0 = (r5 + r6) | 0;
                  r5 = heapClassInst.heapU16[(r1 + numDefine2) >> 1];
                  heapClassInst.heap16[(r0 + numDefine2) >> 1] = r5;
                  r5 = heapClassInst.heapU16[(r1 + numDefine4) >> 1];
                  heapClassInst.heap16[(r0 + numDefine4) >> 1] = r5;
                  r5 = heapClassInst.heapU16[(r1 + numDefine6) >> 1];
                  heapClassInst.heap16[(r0 + numDefine6) >> 1] = r5;
                  r5 = heapClassInst.heapU16[(r1 + numDefine8) >> 1];
                  heapClassInst.heap16[(r0 + numDefine8) >> 1] = r5;
                  r1 = heapClassInst.heapU16[(r1 + numDefine10) >> 1];
                  r5 = r0 >> numDefine2;
                  heapClassInst.heap16[(r0 + numDefine10) >> 1] = r1;
                  r0 = heapClassInst.heap32[fp + numDefineNeg23];
                  heapClassInst.heap32[r5 + numDefine3] = r0;
                  heapClassInst.heap32[r5 + numDefine4] = r2;
                }
                r0 = heapClassInst.heap32[r4 + numDefine38];
                heapClassInst.heap32[r4 + numDefine42] = r0;
                r0 = heapClassInst.heapU8[r3 + numDefine60];
                if (r0 === 0) {
                  break repeat120;
                }
              }
              r0 = heapClassInst.heap32[fp + numDefineNeg21];
              r0 = r0 << numDefine4;
              r4 = heapClassInst.heap32[r4 + numDefine34];
              r4 = (r4 + r0) | 0;
              r0 = 0;
              r4 = r4 >> numDefine2;
              r1 = heapClassInst.heap32[fp + numDefineNeg22];
              r0 = (r0 - r1) | 0;
              heapClassInst.heap32[r4 + numDefine3] = r0;
              return;
            }
          } while (false);
          r0 = heapClassInst.heap32[fp + numDefineNeg21];
          r0 = r0 << numDefine6;
          r1 = heapClassInst.heap32[r4 + numDefine24];
          r0 = (r1 + r0) | 0;
          r0 = r0 >> numDefine2;
          r1 = heapClassInst.heap32[fp + numDefineNeg22];
          heapClassInst.heap32[r0 + numDefine8] = r1;
          return;
        }
      }
      r0 = twoEStr21;
      r1 = twoEStr537;
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r1;
      heapClassInst.heap32[g0 + numDefine2] = numDefine278;
      assertNew(i7);
    } else {
      r1 = heapClassInst.heapU8[r3 + numDefine60];
      if (r1 === 0) {
        r1 = heapClassInst.heap32[r4 + numDefine24];
        r2 = heapClassInst.heap32[r4 + numDefine19];
        r3 = r5 << numDefine6;
        r0 = r0 << numDefine6;
        r1 = (r1 + r3) | 0;
        r0 = (r2 + r0) | 0;
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = r0;
        heapClassInst.heap32[g0 + numDefine2] = numDefine64;
        memcpy(i7);
      } else {
        r0 = r0 << numDefine4;
        r1 = heapClassInst.heap32[r4 + numDefine29];
        r2 = heapClassInst.heap32[r4 + numDefine34];
        r3 = heapClassInst.heapU16[(r1 + r0) >> 1];
        r5 = r5 << numDefine4;
        r0 = (r1 + r0) | 0;
        heapClassInst.heap16[(r2 + r5) >> 1] = r3;
        r1 = (r2 + r5) | 0;
        r2 = heapClassInst.heapU16[(r0 + numDefine2) >> 1];
        heapClassInst.heap16[(r1 + numDefine2) >> 1] = r2;
        r2 = heapClassInst.heapU16[(r0 + numDefine4) >> 1];
        heapClassInst.heap16[(r1 + numDefine4) >> 1] = r2;
        r2 = heapClassInst.heapU16[(r0 + numDefine6) >> 1];
        heapClassInst.heap16[(r1 + numDefine6) >> 1] = r2;
        r2 = heapClassInst.heapU16[(r0 + numDefine8) >> 1];
        heapClassInst.heap16[(r1 + numDefine8) >> 1] = r2;
        r2 = heapClassInst.heapU16[(r0 + numDefine10) >> 1];
        r0 = r0 >> numDefine2;
        heapClassInst.heap16[(r1 + numDefine10) >> 1] = r2;
        r1 = r1 >> numDefine2;
        r0 = heapClassInst.heap32[r0 + numDefine3];
        heapClassInst.heap32[r1 + numDefine3] = r0;
      }
      r0 = heapClassInst.heap32[r4 + numDefine14];
      r0 = (r0 + 1) | 0;
      heapClassInst.heap32[r4 + numDefine14] = r0;
      return;
    }
  } else {
    r0 = twoEStr2246;
    r1 = twoEStr537;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r1;
    heapClassInst.heap32[g0 + numDefine2] = numDefine127;
    assertNew(i7);
  }
}

function zn14btQuantizedBvhD2Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv14btQuantizedBvh;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r1 = heapClassInst.heap32[r2 + numDefine40];
  if (!(r1 === 0)) {
    r3 = heapClassInst.heapU8[r0 + numDefine164];
    if (!(r3 === 0)) {
      r3 = gNumAlignedFree;
      r3 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r3];
      r4 = (r4 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r3] = r4;
      r1 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine40] = 0;
  }
  r1 = 1;
  heapClassInst.heap8[r0 + numDefine164] = r1;
  heapClassInst.heap32[r2 + numDefine40] = 0;
  heapClassInst.heap32[r2 + numDefine38] = 0;
  heapClassInst.heap32[r2 + numDefine39] = 0;
  r3 = heapClassInst.heap32[r2 + numDefine34];
  if (!(r3 === 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine140];
    if (!(r4 === 0)) {
      r4 = gNumAlignedFree;
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4];
      r5 = (r5 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r4] = r5;
      r3 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r3;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine34] = 0;
  }
  heapClassInst.heap8[r0 + numDefine140] = r1;
  heapClassInst.heap32[r2 + numDefine34] = 0;
  heapClassInst.heap32[r2 + numDefine32] = 0;
  heapClassInst.heap32[r2 + numDefine33] = 0;
  r3 = heapClassInst.heap32[r2 + numDefine29];
  if (!(r3 === 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine120];
    if (!(r4 === 0)) {
      r4 = gNumAlignedFree;
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4];
      r5 = (r5 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r4] = r5;
      r3 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r3;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine29] = 0;
  }
  heapClassInst.heap8[r0 + numDefine120] = r1;
  heapClassInst.heap32[r2 + numDefine29] = 0;
  heapClassInst.heap32[r2 + numDefine27] = 0;
  heapClassInst.heap32[r2 + numDefine28] = 0;
  r3 = heapClassInst.heap32[r2 + numDefine24];
  if (!(r3 === 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine100];
    if (!(r4 === 0)) {
      r4 = gNumAlignedFree;
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4];
      r5 = (r5 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r4] = r5;
      r3 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r3;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine24] = 0;
  }
  heapClassInst.heap8[r0 + numDefine100] = r1;
  heapClassInst.heap32[r2 + numDefine24] = 0;
  heapClassInst.heap32[r2 + numDefine22] = 0;
  heapClassInst.heap32[r2 + numDefine23] = 0;
  r3 = heapClassInst.heap32[r2 + numDefine19];
  if (!(r3 === 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine80];
    if (!(r4 === 0)) {
      r4 = gNumAlignedFree;
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4];
      r5 = (r5 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r4] = r5;
      r3 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r3;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine19] = 0;
  }
  heapClassInst.heap8[r0 + numDefine80] = r1;
  heapClassInst.heap32[r2 + numDefine19] = 0;
  heapClassInst.heap32[r2 + numDefine17] = 0;
  heapClassInst.heap32[r2 + numDefine18] = 0;
  return;
}

function zn28btCompoundCollisionAlgorithm26preallocateChildAlgorithmsEP17btCollisionObjectS1(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heapU8[r0 + numDefine28];
  r2 = heapClassInst.heap32[fp + 1];
  r3 = heapClassInst.heap32[fp + numDefine2];
  r4 = r1 === 0 ? r2 : r3;
  r5 = r4 >> numDefine2;
  r6 = heapClassInst.heap32[r5 + numDefine48];
  r6 = r6 >> numDefine2;
  r7 = heapClassInst.heap32[r6 + 1];
  if (r7 === numDefine31) {
    r7 = r0 >> numDefine2;
    r8 = heapClassInst.heap32[r7 + numDefine3];
    r9 = heapClassInst.heap32[r6 + numDefine4];
    repeat3: do {
      if (!(r8 > r9)) {
        if (!(r8 >= r9)) {
          r10 = heapClassInst.heap32[r7 + numDefine4];
          if (!(r10 >= r9)) {
            if (r9 !== 0) {
              r10 = gNumAlignedAllocs;
              r10 = r10 >> numDefine2;
              r11 = heapClassInst.heap32[r10];
              r12 = r9 << numDefine2;
              r11 = (r11 + 1) | 0;
              r12 = r12 | numDefine3;
              heapClassInst.heap32[r10] = r11;
              r10 = (r12 + numDefine16) | 0;
              heapClassInst.heap32[g0] = r10;
              mallocNew(i7);
              r10 = commonVariable.rg0;
              if (r10 !== 0) {
                r11 = 0;
                r12 = (r10 + numDefine4) | 0;
                r11 = (r11 - r12) | 0;
                r11 = r11 & numDefine15;
                r11 = (r10 + r11) | 0;
                r12 = (r11 + numDefine4) | 0;
                r11 = r11 >> numDefine2;
                heapClassInst.heap32[r11] = r10;
                r10 = r12;
              }
            } else {
              r10 = 0;
            }
            r11 = (r0 + numDefine20) | 0;
            if (r8 < 1) {
              r12 = r11 >> numDefine2;
              r13 = heapClassInst.heap32[r12];
            } else {
              r12 = 0;
              repeat16: while (true) {
                r13 = r11 >> numDefine2;
                r13 = heapClassInst.heap32[r13];
                r14 = r12 << numDefine2;
                r15 = (r13 + r14) | 0;
                r15 = r15 >> numDefine2;
                r14 = (r10 + r14) | 0;
                r15 = heapClassInst.heap32[r15];
                r12 = (r12 + 1) | 0;
                r14 = r14 >> numDefine2;
                heapClassInst.heap32[r14] = r15;
                if (!(r8 !== r12)) {
                  break repeat16;
                }
              }
              r11 = (r0 + numDefine20) | 0;
            }
            if (!(r13 === 0)) {
              r12 = heapClassInst.heapU8[r0 + numDefine24];
              if (!(r12 === 0)) {
                r12 = gNumAlignedFree;
                r12 = r12 >> numDefine2;
                r14 = heapClassInst.heap32[r12];
                r14 = (r14 + 1) | 0;
                r13 = r13 >> numDefine2;
                heapClassInst.heap32[r12] = r14;
                r12 = heapClassInst.heap32[r13 + -1];
                heapClassInst.heap32[g0] = r12;
                free(i7);
              }
              r12 = r11 >> numDefine2;
              heapClassInst.heap32[r12] = 0;
            }
            r12 = 1;
            r11 = r11 >> numDefine2;
            heapClassInst.heap8[r0 + numDefine24] = r12;
            heapClassInst.heap32[r11] = r10;
            heapClassInst.heap32[r7 + numDefine4] = r9;
            if (r8 >= r9) {
              break repeat3;
            }
          }
          while (true) {
            r0 = r8 << numDefine2;
            r10 = heapClassInst.heap32[r7 + numDefine5];
            r0 = (r10 + r0) | 0;
            r8 = (r8 + 1) | 0;
            r0 = r0 >> numDefine2;
            heapClassInst.heap32[r0] = 0;
            if (!(r9 !== r8)) {
              break repeat3;
            }
          }
        }
      }
    } while (false);
    heapClassInst.heap32[r7 + numDefine3] = r9;
    repeat29: do {
      if (!(r9 < 1)) {
        r0 = r1 === 0 ? r3 : r2;
        r1 = 0;
        while (true) {
          r2 = heapClassInst.heap32[r6 + numDefine16];
          if (r2 === 0) {
            r2 = (r1 * numDefine20) | 0;
            r2 = r2 << numDefine2;
            r3 = heapClassInst.heap32[r6 + numDefine6];
            r2 = (r3 + r2) | 0;
            r2 = r2 >> numDefine2;
            r3 = heapClassInst.heap32[r5 + numDefine48];
            r2 = heapClassInst.heap32[r2 + numDefine16];
            heapClassInst.heap32[r5 + numDefine48] = r2;
            r2 = heapClassInst.heap32[r7 + 1];
            r8 = r2 >> numDefine2;
            r8 = heapClassInst.heap32[r8];
            r8 = r8 >> numDefine2;
            r8 = heapClassInst.heap32[r8 + numDefine2];
            r10 = heapClassInst.heap32[r7 + numDefine8];
            r11 = heapClassInst.heap32[r7 + numDefine5];
            r12 = r1 << numDefine2;
            heapClassInst.heap32[g0] = r2;
            heapClassInst.heap32[g0 + 1] = r4;
            heapClassInst.heap32[g0 + numDefine2] = r0;
            heapClassInst.heap32[g0 + numDefine3] = r10;
            r2 = (r11 + r12) | 0;
            r2 = r2 >> numDefine2;
            functionTable[r8 >> numDefine2](i7);
            heapClassInst.heap32[r2] = commonVariable.rg0;
            heapClassInst.heap32[r5 + numDefine48] = r3;
          } else {
            r2 = r1 << numDefine2;
            r3 = heapClassInst.heap32[r7 + numDefine5];
            r2 = (r3 + r2) | 0;
            r2 = r2 >> numDefine2;
            heapClassInst.heap32[r2] = 0;
          }
          r1 = (r1 + 1) | 0;
          if (!(r9 !== r1)) {
            break repeat29;
          }
        }
      }
    } while (false);
    return;
  } else {
    r0 = twoEStr99;
    r1 = twoEStr1100;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r1;
    heapClassInst.heap32[g0 + numDefine2] = numDefine44;
    assertNew(i7);
  }
}

function znk14btQuantizedBvh26reportAabbOverlappingNodexEP21btNodeOverlapCallbackRK9btVector3S4(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg40;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = heapClassInst.heap32[fp + numDefine2];
  r3 = heapClassInst.heap32[fp + numDefine3];
  r4 = heapClassInst.heapU8[r0 + numDefine60];
  repeat1: do {
    if (r4 === 0) {
      r0 = r0 >> numDefine2;
      r4 = heapClassInst.heap32[r0 + numDefine24];
      r5 = 0;
      r6 = r5;
      repeat3: while (true) {
        r7 = heapClassInst.heap32[r0 + numDefine14];
        if (r7 > r5) {
          if (r7 > r6) {
            r7 = r2 >> numDefine2;
            r8 = r4 >> numDefine2;
            r6 = (r6 + 1) | 0;
            f0 = heapClassInst.heapFloat[r7];
            f1 = heapClassInst.heapFloat[r8 + numDefine4];
            if (f0 > f1) {
              label = numDefine26;
            } else {
              r9 = r3 >> numDefine2;
              f0 = heapClassInst.heapFloat[r9];
              f1 = heapClassInst.heapFloat[r8];
              if (f0 < f1) {
                label = numDefine26;
              } else {
                r9 = 1;
                label = numDefine27;
              }
            }
            if (label === numDefine26) {
              r9 = 0;
            }
            f0 = heapClassInst.heapFloat[r7 + numDefine2];
            f1 = heapClassInst.heapFloat[r8 + numDefine6];
            if (f0 > f1) {
              label = numDefine29;
            } else {
              r10 = r3 >> numDefine2;
              f0 = heapClassInst.heapFloat[r10 + numDefine2];
              f1 = heapClassInst.heapFloat[r8 + numDefine2];
              if (f0 < f1) {
                label = numDefine29;
              } else {
                label = numDefine30;
              }
            }
            if (label === numDefine29) {
              r9 = 0;
            }
            f0 = heapClassInst.heapFloat[r7 + 1];
            f1 = heapClassInst.heapFloat[r8 + numDefine5];
            if (f0 <= f1) {
              r7 = r3 >> numDefine2;
              f0 = heapClassInst.heapFloat[r7 + 1];
              f1 = heapClassInst.heapFloat[r8 + 1];
              r7 = 0;
              r10 = heapClassInst.heap32[r8 + numDefine8];
              r11 = -1;

              r9 = f0 < f1 ? r7 : r9;
              r7 = r10 === r11 ? 1 : 0;

              r12 = r9 & numDefine255;
              if (!(r12 === 0)) {
                r10 = r10 !== r11 ? 1 : 0;

                r10 = r10 & 1;
                if (r10 === 0) {
                  r10 = r1 >> numDefine2;
                  r10 = heapClassInst.heap32[r10];
                  r10 = r10 >> numDefine2;
                  r10 = heapClassInst.heap32[r10 + numDefine2];
                  r11 = heapClassInst.heap32[r8 + numDefine10];
                  r12 = heapClassInst.heap32[r8 + numDefine9];
                  heapClassInst.heap32[g0] = r1;
                  heapClassInst.heap32[g0 + 1] = r12;
                  heapClassInst.heap32[g0 + numDefine2] = r11;
                  functionTable[r10 >> numDefine2](i7);
                }
              }
            } else {
              r7 = heapClassInst.heap32[r8 + numDefine8];
              r9 = -1;

              r7 = r7 === r9 ? 1 : 0;

              r9 = 0;
            }
            r9 = r9 & numDefine255;
            if (!(r9 !== 0)) {
              r7 = r7 & 1;
              if (r7 === 0) {
                r7 = heapClassInst.heap32[r8 + numDefine8];
                r8 = r7 << numDefine6;
                r4 = (r4 + r8) | 0;
                r5 = (r7 + r5) | 0;
                continue repeat3;
              }
            }
            r4 = (r4 + numDefine64) | 0;
            r5 = (r5 + 1) | 0;
          } else {
            label = numDefine22;
            break repeat3;
          }
        } else {
          label = numDefine40;
          break repeat3;
        }
      }
      switch (label) {
        case numDefine40:
          r0 = maxIterations;
          r0 = r0 >> numDefine2;
          r1 = heapClassInst.heap32[r0];
          if (r1 >= r6) {
            break repeat1;
          } else {
            heapClassInst.heap32[r0] = r6;
            return;
          }
        case numDefine22:
          r0 = twoEStr1921;
          r1 = twoEStr537;
          heapClassInst.heap32[g0] = r0;
          heapClassInst.heap32[g0 + 1] = r1;
          heapClassInst.heap32[g0 + numDefine2] = numDefine367;
          assertNew(i7);
          break;
        default:
          break;
      }
    } else {
      r4 = sp + numDefineNeg6;
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r4;
      heapClassInst.heap32[g0 + numDefine2] = r2;
      heapClassInst.heap32[g0 + numDefine3] = 0;
      znk14btQuantizedBvh17quantizeWithClampEPtRK9btVector3i(i7);
      r2 = sp + numDefineNeg12;
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r2;
      heapClassInst.heap32[g0 + numDefine2] = r3;
      heapClassInst.heap32[g0 + numDefine3] = 1;
      r3 = r0 >> numDefine2;
      znk14btQuantizedBvh17quantizeWithClampEPtRK9btVector3i(i7);
      r5 = heapClassInst.heap32[r3 + numDefine36];
      if (r5 === numDefine2) {
        r3 = heapClassInst.heap32[r3 + numDefine34];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r3;
        heapClassInst.heap32[g0 + numDefine2] = r1;
        heapClassInst.heap32[g0 + numDefine3] = r4;
        heapClassInst.heap32[g0 + numDefine4] = r2;
        znk14btQuantizedBvh42walkRecursiveQuantizedTreeAgainstQueryAabbEPK18btQuantizedBvhNodeP21btNodeOverlapCallbackPtS5(i7);
        return;
      } else {
        if (r5 === 1) {
          r5 = heapClassInst.heapU8[r0 + numDefine60];
          if (r5 === 0) {
            r2 = twoEStr212;
            r3 = twoEStr537;
            heapClassInst.heap32[g0] = r2;
            heapClassInst.heap32[g0 + 1] = r3;
            heapClassInst.heap32[g0 + numDefine2] = numDefine735;
            assertNew(i7);
          } else {
            r5 = heapClassInst.heap32[r3 + numDefine38];
            if (r5 > 0) {
              r5 = 0;
              repeat42: while (true) {
                r6 = heapClassInst.heap32[r3 + numDefine40];
                r7 = r5 << numDefine5;
                r8 = (r6 + r7) | 0;
                r9 = heapClassInst.heapU16[(sp + numDefineNeg6) >> 1];
                r10 = heapClassInst.heapU16[(r8 + numDefine6) >> 1];
                if (!(uint(r9) > uint(r10))) {
                  r9 = heapClassInst.heapU16[(sp + numDefineNeg12) >> 1];
                  r6 = heapClassInst.heapU16[(r6 + r7) >> 1];
                  r7 = r9 & numDefine65535;
                  r6 = r6 & numDefine65535;
                  if (!(uint(r7) < uint(r6))) {
                    r6 = heapClassInst.heapU16[(sp + numDefineNeg2) >> 1];
                    r7 = heapClassInst.heapU16[(r8 + numDefine10) >> 1];
                    r6 = r6 & numDefine65535;
                    r7 = r7 & numDefine65535;
                    if (!(uint(r6) > uint(r7))) {
                      r6 = heapClassInst.heapU16[(sp + numDefineNeg8) >> 1];
                      r7 = heapClassInst.heapU16[(r8 + numDefine4) >> 1];
                      r6 = r6 & numDefine65535;
                      r7 = r7 & numDefine65535;
                      if (!(uint(r6) < uint(r7))) {
                        r6 = heapClassInst.heapU16[(sp + numDefineNeg4) >> 1];
                        r7 = heapClassInst.heapU16[(r8 + numDefine8) >> 1];
                        r6 = r6 & numDefine65535;
                        r7 = r7 & numDefine65535;
                        if (!(uint(r6) > uint(r7))) {
                          r6 = heapClassInst.heapU16[(sp + numDefineNeg10) >> 1];
                          r7 = heapClassInst.heapU16[(r8 + numDefine2) >> 1];
                          r6 = r6 & numDefine65535;
                          r7 = r7 & numDefine65535;
                          if (!(uint(r6) < uint(r7))) {
                            r6 = r8 >> numDefine2;
                            r7 = heapClassInst.heap32[r6 + numDefine3];
                            r6 = heapClassInst.heap32[r6 + numDefine4];
                            r6 = (r6 + r7) | 0;
                            heapClassInst.heap32[g0] = r0;
                            heapClassInst.heap32[g0 + 1] = r1;
                            heapClassInst.heap32[g0 + numDefine2] = r4;
                            heapClassInst.heap32[g0 + numDefine3] = r2;
                            heapClassInst.heap32[g0 + numDefine4] = r7;
                            heapClassInst.heap32[g0 + numDefine5] = r6;
                            znk14btQuantizedBvh26walkStacklessQuantizedTreeEP21btNodeOverlapCallbackPtS2Ii(i7);
                          }
                        }
                      }
                    }
                  }
                }
                r5 = (r5 + 1) | 0;
                r6 = heapClassInst.heap32[r3 + numDefine38];
                if (r6 > r5) {
                  continue repeat42;
                } else {
                  break repeat1;
                }
              }
            } else {
              break repeat1;
            }
          }
        } else {
          if (r5 !== 0) {
            r0 = twoEStr10;
            r1 = twoEStr537;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = numDefine341;
            assertNew(i7);
          } else {
            r3 = heapClassInst.heap32[r3 + numDefine14];
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = r4;
            heapClassInst.heap32[g0 + numDefine3] = r2;
            heapClassInst.heap32[g0 + numDefine4] = 0;
            heapClassInst.heap32[g0 + numDefine5] = r3;
            znk14btQuantizedBvh26walkStacklessQuantizedTreeEP21btNodeOverlapCallbackPtS2Ii(i7);
            return;
          }
        }
      }
    }
  } while (false);
  return;
}

function znk14btQuantizedBvh17quantizeWithClampEPtRK9btVector3i(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg32;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heapU8[r0 + numDefine60];
  if (r1 !== 0) {
    r1 = heapClassInst.heap32[fp + 1];
    r2 = heapClassInst.heap32[fp + numDefine2];
    r3 = heapClassInst.heap32[fp + numDefine3];
    r2 = r2 >> numDefine2;
    f0 = heapClassInst.heapFloat[r2];
    r4 = sp + numDefineNeg16;
    heapClassInst.heapFloat[fp + numDefineNeg4] = f0;
    f1 = heapClassInst.heapFloat[r2 + 1];
    r5 = r4 >> numDefine2;
    heapClassInst.heapFloat[r5 + 1] = f1;
    f2 = heapClassInst.heapFloat[r2 + numDefine2];
    heapClassInst.heapFloat[r5 + numDefine2] = f2;
    f3 = heapClassInst.heapFloat[r2 + numDefine3];
    r2 = r0 >> numDefine2;
    heapClassInst.heapFloat[r5 + numDefine3] = f3;
    f4 = heapClassInst.heapFloat[r2 + 1];
    if (f0 < f4) {
      heapClassInst.heapFloat[fp + numDefineNeg4] = f4;
      f0 = f4;
    }
    f4 = heapClassInst.heapFloat[r2 + numDefine2];
    if (f1 < f4) {
      heapClassInst.heapFloat[r5 + 1] = f4;
      f1 = f4;
    }
    f4 = heapClassInst.heapFloat[r2 + numDefine3];
    if (f2 < f4) {
      heapClassInst.heapFloat[r5 + numDefine2] = f4;
      f2 = f4;
    }
    f4 = heapClassInst.heapFloat[r2 + numDefine4];
    if (f3 < f4) {
      heapClassInst.heapFloat[r5 + numDefine3] = f4;
      f3 = f4;
    }
    f4 = heapClassInst.heapFloat[r2 + numDefine5];
    if (!(f4 >= f0)) {
      heapClassInst.heapFloat[fp + numDefineNeg4] = f4;
    }
    f0 = heapClassInst.heapFloat[r2 + numDefine6];
    if (!(f0 >= f1)) {
      heapClassInst.heapFloat[r5 + 1] = f0;
    }
    f0 = heapClassInst.heapFloat[r2 + numDefine7];
    if (!(f0 >= f2)) {
      heapClassInst.heapFloat[r5 + numDefine2] = f0;
    }
    f0 = heapClassInst.heapFloat[r2 + numDefine8];
    if (!(f0 >= f3)) {
      heapClassInst.heapFloat[r5 + numDefine3] = f0;
    }
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r1;
    heapClassInst.heap32[g0 + numDefine2] = r4;
    heapClassInst.heap32[g0 + numDefine3] = r3;
    znk14btQuantizedBvh8quantizeEPtRK9btVector3i(i7);
    return;
  } else {
    r0 = twoEStr212;
    r1 = twoEStr313;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r1;
    heapClassInst.heap32[g0 + numDefine2] = numDefine420;
    assertNew(i7);
  }
}

function znk14btQuantizedBvh26walkStacklessQuantizedTreeEP21btNodeOverlapCallbackPtS2Ii(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heapU8[r0 + numDefine60];
  if (r1 !== 0) {
    r1 = heapClassInst.heap32[fp + 1];
    r2 = heapClassInst.heap32[fp + numDefine2];
    r3 = heapClassInst.heap32[fp + numDefine3];
    r4 = heapClassInst.heap32[fp + numDefine4];
    r5 = heapClassInst.heap32[fp + numDefine5];
    r0 = r0 >> numDefine2;
    r0 = heapClassInst.heap32[r0 + numDefine34];
    r6 = r4 << numDefine4;
    r7 = (r5 - r4) | 0;
    r0 = (r0 + r6) | 0;
    r6 = 0;
    repeat3: while (true) {
      if (r4 < r5) {
        if (r6 < r7) {
          r8 = heapClassInst.heapU16[r2 >> 1];
          r9 = heapClassInst.heapU16[(r0 + numDefine6) >> 1];
          r10 = heapClassInst.heapU16[r3 >> 1];
          r11 = heapClassInst.heapU16[r0 >> 1];

          r8 = uint(r8) > uint(r9) ? 1 : 0;
          r9 = uint(r10) < uint(r11) ? 1 : 0;

          r10 = heapClassInst.heapU16[(r2 + numDefine4) >> 1];
          r11 = heapClassInst.heapU16[(r0 + numDefine10) >> 1];
          r8 = r8 | r9;

          r9 = uint(r10) > uint(r11) ? 1 : 0;
          r10 = heapClassInst.heapU16[(r3 + numDefine4) >> 1];
          r11 = heapClassInst.heapU16[(r0 + numDefine4) >> 1];
          r8 = r8 | r9;

          r9 = uint(r10) < uint(r11) ? 1 : 0;
          r10 = heapClassInst.heapU16[(r2 + numDefine2) >> 1];
          r11 = heapClassInst.heapU16[(r0 + numDefine8) >> 1];
          r8 = r8 | r9;

          r9 = uint(r10) > uint(r11) ? 1 : 0;
          r10 = heapClassInst.heapU16[(r3 + numDefine2) >> 1];
          r11 = heapClassInst.heapU16[(r0 + numDefine2) >> 1];
          r12 = r0 >> numDefine2;
          r8 = r8 | r9;

          r9 = uint(r10) < uint(r11) ? 1 : 0;
          r10 = heapClassInst.heap32[r12 + numDefine3];
          r6 = (r6 + 1) | 0;
          r8 = r8 | r9;
          if (r10 < 0) {
            label = numDefine10;
          } else {
            if (r8 !== 0) {
              label = numDefine10;
            } else {
              if (r10 > -1) {
                r8 = r1 >> numDefine2;
                r8 = heapClassInst.heap32[r8];
                r8 = r8 >> numDefine2;
                r8 = heapClassInst.heap32[r8 + numDefine2];
                r12 = r10 >> numDefine21;
                r10 = r10 & numDefine97151;
                heapClassInst.heap32[g0] = r1;
                heapClassInst.heap32[g0 + 1] = r12;
                heapClassInst.heap32[g0 + numDefine2] = r10;
                functionTable[r8 >> numDefine2](i7);
                label = numDefine11;
              } else {
                label = numDefine8;
                break repeat3;
              }
            }
          }
          if (label === numDefine10) {
            r9 = 0;

            r9 = r10 < r9 ? 1 : 0;
            r8 = r9 & r8;
            if (r8 !== 0) {
              r8 = heapClassInst.heap32[r12 + numDefine3];
              if (r8 < 0) {
                r9 = r8 << numDefine4;
                r0 = (r0 - r9) | 0;
                r4 = (r4 - r8) | 0;
                continue repeat3;
              } else {
                label = numDefine13;
                break repeat3;
              }
            }
          }
          r0 = (r0 + numDefine16) | 0;
          r4 = (r4 + 1) | 0;
        } else {
          label = numDefine4;
          break repeat3;
        }
      } else {
        label = numDefine16;
        break repeat3;
      }
    }
    switch (label) {
      case numDefine16:
        r0 = maxIterations;
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0];
        if (!(r1 >= r6)) {
          heapClassInst.heap32[r0] = r6;
        }
        return;
      case numDefine13:
        r0 = twoEStr941;
        r1 = twoEStr313;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r1;
        heapClassInst.heap32[g0 + numDefine2] = numDefine75;
        assertNew(i7);
        break;
      case numDefine8:
        r0 = twoEStr739;
        r1 = twoEStr313;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r1;
        heapClassInst.heap32[g0 + numDefine2] = numDefine80;
        assertNew(i7);
        break;
      case numDefine4:
        r0 = twoEStr1143;
        r1 = twoEStr537;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r1;
        heapClassInst.heap32[g0 + numDefine2] = numDefine703;
        assertNew(i7);
        break;
      default:
        break;
    }
  } else {
    r0 = twoEStr212;
    r1 = twoEStr537;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r1;
    heapClassInst.heap32[g0 + numDefine2] = numDefine669;
    assertNew(i7);
  }
}

function znk14btQuantizedBvh42walkRecursiveQuantizedTreeAgainstQueryAabbEPK18btQuantizedBvhNodeP21btNodeOverlapCallbackPtS5(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = heapClassInst.heap32[fp + numDefine2];
  r3 = heapClassInst.heap32[fp + numDefine3];
  r4 = heapClassInst.heap32[fp + numDefine4];
  repeat1: while (true) {
    r5 = heapClassInst.heapU8[r0 + numDefine60];
    if (r5 !== 0) {
      r5 = heapClassInst.heapU16[r3 >> 1];
      r6 = heapClassInst.heapU16[(r1 + numDefine6) >> 1];
      if (uint(r5) > uint(r6)) {
        label = numDefine14;
        break repeat1;
      } else {
        r5 = heapClassInst.heapU16[r4 >> 1];
        r6 = heapClassInst.heapU16[r1 >> 1];
        r5 = r5 & numDefine65535;
        r6 = r6 & numDefine65535;
        if (uint(r5) < uint(r6)) {
          label = numDefine14;
          break repeat1;
        } else {
          r5 = heapClassInst.heapU16[(r3 + numDefine4) >> 1];
          r6 = heapClassInst.heapU16[(r1 + numDefine10) >> 1];
          r5 = r5 & numDefine65535;
          r6 = r6 & numDefine65535;
          if (uint(r5) > uint(r6)) {
            label = numDefine14;
            break repeat1;
          } else {
            r5 = heapClassInst.heapU16[(r4 + numDefine4) >> 1];
            r6 = heapClassInst.heapU16[(r1 + numDefine4) >> 1];
            r5 = r5 & numDefine65535;
            r6 = r6 & numDefine65535;
            if (uint(r5) < uint(r6)) {
              label = numDefine14;
              break repeat1;
            } else {
              r5 = heapClassInst.heapU16[(r3 + numDefine2) >> 1];
              r6 = heapClassInst.heapU16[(r1 + numDefine8) >> 1];
              r5 = r5 & numDefine65535;
              r6 = r6 & numDefine65535;
              if (uint(r5) > uint(r6)) {
                label = numDefine14;
                break repeat1;
              } else {
                r5 = heapClassInst.heapU16[(r4 + numDefine2) >> 1];
                r6 = heapClassInst.heapU16[(r1 + numDefine2) >> 1];
                r5 = r5 & numDefine65535;
                r6 = r6 & numDefine65535;
                if (uint(r5) < uint(r6)) {
                  label = numDefine14;
                  break repeat1;
                } else {
                  r5 = r1 >> numDefine2;
                  r6 = heapClassInst.heap32[r5 + numDefine3];
                  if (r6 < 0) {
                    r6 = (r1 + numDefine16) | 0;
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = r6;
                    heapClassInst.heap32[g0 + numDefine2] = r2;
                    heapClassInst.heap32[g0 + numDefine3] = r3;
                    heapClassInst.heap32[g0 + numDefine4] = r4;
                    znk14btQuantizedBvh42walkRecursiveQuantizedTreeAgainstQueryAabbEPK18btQuantizedBvhNodeP21btNodeOverlapCallbackPtS5(i7);
                    r5 = heapClassInst.heap32[r5 + numDefine7];
                    if (r5 < 0) {
                      r6 = 1;
                      r5 = (r6 - r5) | 0;
                      r5 = r5 << numDefine4;
                      r1 = (r1 + r5) | 0;
                      continue repeat1;
                    } else {
                      r1 = (r1 + numDefine32) | 0;
                      continue repeat1;
                    }
                  } else {
                    label = numDefine10;
                    break repeat1;
                  }
                }
              }
            }
          }
        }
      }
    } else {
      label = numDefine2;
      break repeat1;
    }
  }
  switch (label) {
    case numDefine14:
      return;
    case numDefine2:
      r0 = twoEStr212;
      r1 = twoEStr537;
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r1;
      heapClassInst.heap32[g0 + numDefine2] = numDefine419;
      assertNew(i7);
      break;
    case numDefine10:
      r0 = r2 >> numDefine2;
      r0 = heapClassInst.heap32[r0];
      r0 = r0 >> numDefine2;
      r0 = heapClassInst.heap32[r0 + numDefine2];
      r1 = r6 >> numDefine21;
      r3 = r6 & numDefine97151;
      heapClassInst.heap32[g0] = r2;
      heapClassInst.heap32[g0 + 1] = r1;
      heapClassInst.heap32[g0 + numDefine2] = r3;
      functionTable[r0 >> numDefine2](i7);
      return;
    default:
      break;
  }
}

function zn15btTransformUtil22calculateDiffAxisAngleERK11btTransformS2R9btVector3Rf(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let f12: number = 0.0;
  let f13: number = 0.0;
  let f14: number = 0.0;
  let f15: number = 0.0;
  let f16: number = 0.0;
  let f17: number = 0.0;
  let f18: number = 0.0;
  let f19: number = 0.0;
  let f20: number = 0.0;
  let f21: number = 0.0;
  let f22: number = 0.0;
  let f23: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg80;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  f0 = heapClassInst.heapFloat[r0 + numDefine4];
  f1 = heapClassInst.heapFloat[r0 + numDefine9];
  f2 = heapClassInst.heapFloat[r0 + numDefine6];
  f3 = heapClassInst.heapFloat[r0 + numDefine8];
  f4 = heapClassInst.heapFloat[r0 + numDefine5];
  f5 = heapClassInst.heapFloat[r0 + numDefine10];
  f6 = f4 * f5;
  f7 = f2 * f1;
  f8 = f2 * f3;
  f9 = f0 * f5;
  f10 = heapClassInst.heapFloat[r0];
  f11 = heapClassInst.heapFloat[r0 + 1];
  f6 = f6 - f7;
  f7 = f8 - f9;
  f8 = f0 * f1;
  f9 = f4 * f3;
  f12 = heapClassInst.heapFloat[r0 + numDefine2];
  f8 = f8 - f9;
  f9 = f10 * f6;
  f13 = f11 * f7;
  f9 = f9 + f13;
  f13 = f12 * f8;
  r0 = heapClassInst.heap32[fp + 1];
  f14 = 1;
  f9 = f9 + f13;
  r0 = r0 >> numDefine2;
  f9 = f14 / f9;
  f13 = f12 * f1;
  f15 = f11 * f5;
  f5 = f10 * f5;
  f16 = f12 * f3;
  f13 = f13 - f15;
  f5 = f5 - f16;
  f15 = f11 * f2;
  f16 = f12 * f4;
  f12 = f12 * f0;
  f2 = f10 * f2;
  f3 = f11 * f3;
  f1 = f10 * f1;
  f6 = f6 * f9;
  f17 = heapClassInst.heapFloat[r0];
  f7 = f7 * f9;
  f18 = heapClassInst.heapFloat[r0 + 1];
  f15 = f15 - f16;
  f2 = f12 - f2;
  f12 = f13 * f9;
  f5 = f5 * f9;
  f1 = f3 - f1;
  f3 = f10 * f4;
  f0 = f11 * f0;
  f4 = f6 * f17;
  f10 = f7 * f18;
  f8 = f8 * f9;
  f11 = heapClassInst.heapFloat[r0 + numDefine2];
  f13 = heapClassInst.heapFloat[r0 + numDefine8];
  f15 = f15 * f9;
  f16 = heapClassInst.heapFloat[r0 + numDefine4];
  f19 = heapClassInst.heapFloat[r0 + numDefine9];
  f2 = f2 * f9;
  f20 = heapClassInst.heapFloat[r0 + numDefine5];
  f0 = f3 - f0;
  f1 = f1 * f9;
  f3 = heapClassInst.heapFloat[r0 + numDefine10];
  f21 = heapClassInst.heapFloat[r0 + numDefine6];
  f22 = f12 * f17;
  f23 = f5 * f18;
  f4 = f4 + f10;
  f10 = f8 * f11;
  f0 = f0 * f9;
  r0 = sp + numDefineNeg48;
  f9 = f15 * f17;
  f17 = f2 * f18;
  f18 = f22 + f23;
  f22 = f1 * f11;
  f4 = f4 + f10;
  r1 = r0 >> numDefine2;
  f9 = f9 + f17;
  f10 = f0 * f11;
  f11 = f18 + f22;
  heapClassInst.heapFloat[fp + numDefineNeg12] = f4;
  f4 = f6 * f16;
  f17 = f7 * f20;
  f9 = f9 + f10;
  heapClassInst.heapFloat[r1 + 1] = f11;
  heapClassInst.heapFloat[r1 + numDefine2] = f9;
  f9 = f12 * f16;
  f10 = f5 * f20;
  f4 = f4 + f17;
  f11 = f8 * f21;
  f16 = f15 * f16;
  f17 = f2 * f20;
  f9 = f9 + f10;
  f10 = f1 * f21;
  f4 = f4 + f11;
  heapClassInst.heap32[r1 + numDefine3] = 0;
  f11 = f16 + f17;
  f16 = f0 * f21;
  f9 = f9 + f10;
  heapClassInst.heapFloat[r1 + numDefine4] = f4;
  f4 = f6 * f13;
  f6 = f7 * f19;
  f7 = f11 + f16;
  heapClassInst.heapFloat[r1 + numDefine5] = f9;
  heapClassInst.heapFloat[r1 + numDefine6] = f7;
  f7 = f12 * f13;
  f5 = f5 * f19;
  f4 = f4 + f6;
  f6 = f8 * f3;
  f8 = f15 * f13;
  f2 = f2 * f19;
  f5 = f7 + f5;
  f1 = f1 * f3;
  f4 = f4 + f6;
  heapClassInst.heap32[r1 + numDefine7] = 0;
  f2 = f8 + f2;
  f0 = f0 * f3;
  f1 = f5 + f1;
  heapClassInst.heapFloat[r1 + numDefine8] = f4;
  f0 = f2 + f0;
  heapClassInst.heapFloat[r1 + numDefine9] = f1;
  heapClassInst.heapFloat[r1 + numDefine10] = f0;
  heapClassInst.heap32[r1 + numDefine11] = 0;
  r1 = sp + numDefineNeg64;
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r1;
  znk11btMatrix3x311getRotationER12btQuaternion(i7);
  r0 = r1 >> numDefine2;
  f0 = heapClassInst.heapFloat[fp + numDefineNeg16];
  f1 = heapClassInst.heapFloat[r0 + 1];
  f2 = heapClassInst.heapFloat[r0 + numDefine2];
  f3 = f0 * f0;
  f4 = f1 * f1;
  f5 = heapClassInst.heapFloat[r0 + numDefine3];
  f3 = f3 + f4;
  f4 = f2 * f2;
  f3 = f3 + f4;
  f4 = f5 * f5;
  f3 = f3 + f4;
  heapClassInst.heapFloat[g0] = f3;
  sqrtf(i7);
  f3 = commonVariable.fg0;
  f4 = 0;
  if (f3 !== f4) {
    r1 = heapClassInst.heap32[fp + numDefine2];
    r2 = heapClassInst.heap32[fp + numDefine3];
    f3 = f14 / f3;
    f0 = f0 * f3;
    f1 = f1 * f3;
    heapClassInst.heapFloat[fp + numDefineNeg16] = f0;
    f2 = f2 * f3;
    heapClassInst.heapFloat[r0 + 1] = f1;
    f4 = -1;
    f3 = f5 * f3;
    heapClassInst.heapFloat[r0 + numDefine2] = f2;
    f4 = f3 < f4 ? f4 : f3;
    heapClassInst.heapFloat[r0 + numDefine3] = f3;
    f3 = f4 > f14 ? f14 : f4;
    heapClassInst.heapFloat[g0] = f3;
    acosf(i7);
    r0 = r2 >> numDefine2;
    f3 = commonVariable.fg0 + commonVariable.fg0;
    r1 = r1 >> numDefine2;
    heapClassInst.heapFloat[r0] = f3;
    heapClassInst.heapFloat[r1] = f0;
    f0 = f0 * f0;
    f3 = f1 * f1;
    heapClassInst.heapFloat[r1 + 1] = f1;
    f0 = f0 + f3;
    f1 = f2 * f2;
    f0 = f0 + f1;
    heapClassInst.heapFloat[r1 + numDefine2] = f2;
    heapClassInst.heap32[r1 + numDefine3] = 0;
    f1 = numDefineFloat4044;
    if (f0 >= f1) {
      heapClassInst.heapFloat[g0] = f0;
      sqrtf(i7);
      f0 = f14 / commonVariable.fg0;
      f1 = heapClassInst.heapFloat[r1];
      f1 = f1 * f0;
      heapClassInst.heapFloat[r1] = f1;
      f1 = heapClassInst.heapFloat[r1 + 1];
      f1 = f1 * f0;
      heapClassInst.heapFloat[r1 + 1] = f1;
      f1 = heapClassInst.heapFloat[r1 + numDefine2];
      f0 = f1 * f0;
      heapClassInst.heapFloat[r1 + numDefine2] = f0;
      return;
    } else {
      heapClassInst.heap32[r1] = numDefine53216;
      heapClassInst.heap32[r1 + 1] = 0;
      heapClassInst.heap32[r1 + numDefine2] = 0;
      heapClassInst.heap32[r1 + numDefine3] = 0;
      return;
    }
  } else {
    r0 = twoEStr584;
    r1 = twoEStr685;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r1;
    heapClassInst.heap32[g0 + numDefine2] = numDefine188;
    assertNew(i7);
  }
}

function znk11btMatrix3x311getRotationER12btQuaternion(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  f0 = heapClassInst.heapFloat[r1];
  f1 = heapClassInst.heapFloat[r1 + numDefine5];
  f2 = heapClassInst.heapFloat[r1 + numDefine10];
  f3 = f0 + f1;
  f3 = f3 + f2;
  r2 = heapClassInst.heap32[fp + 1];
  f4 = 0;
  if (f3 <= f4) {
    if (f0 >= f1) {
      r1 = numDefine2;
      r3 = 0;
      r1 = f0 < f2 ? r1 : r3;
    } else {
      r1 = numDefine2;
      r3 = 1;
      r1 = f1 < f2 ? r1 : r3;
    }
    r3 = (r1 + 1) | 0;
    r3 = r3 % numDefine3 | 0;
    r4 = (r1 + numDefine2) | 0;
    r4 = r4 % numDefine3 | 0;
    r5 = r1 << numDefine4;
    r6 = r3 << numDefine4;
    r7 = r4 << numDefine4;
    r5 = (r0 + r5) | 0;
    r1 = r1 << numDefine2;
    r6 = (r0 + r6) | 0;
    r3 = r3 << numDefine2;
    r0 = (r0 + r7) | 0;
    r4 = r4 << numDefine2;
    r7 = (r5 + r1) | 0;
    r8 = (r6 + r3) | 0;
    r7 = r7 >> numDefine2;
    r8 = r8 >> numDefine2;
    r9 = (r0 + r4) | 0;
    r9 = r9 >> numDefine2;
    f0 = heapClassInst.heapFloat[r7];
    f1 = heapClassInst.heapFloat[r8];
    f2 = heapClassInst.heapFloat[r9];
    f0 = f0 - f1;
    f0 = f0 - f2;
    f1 = 1;
    f0 = f0 + f1;
    r7 = sp + numDefineNeg16;
    heapClassInst.heapFloat[g0] = f0;
    r8 = (r7 + r1) | 0;
    f0 = numDefineFloat05;
    sqrtf(i7);
    r9 = (r0 + r3) | 0;
    r10 = (r6 + r4) | 0;
    r8 = r8 >> numDefine2;
    f2 = commonVariable.fg0 * f0;
    r9 = r9 >> numDefine2;
    heapClassInst.heapFloat[r8] = f2;
    r8 = r10 >> numDefine2;
    f2 = heapClassInst.heapFloat[r9];
    f3 = heapClassInst.heapFloat[r8];
    f2 = f2 - f3;
    f0 = f0 / commonVariable.fg0;
    r6 = (r6 + r1) | 0;
    r8 = (r5 + r3) | 0;
    r9 = r7 >> numDefine2;
    f1 = f2 * f0;
    r6 = r6 >> numDefine2;
    heapClassInst.heapFloat[r9 + numDefine3] = f1;
    r8 = r8 >> numDefine2;
    f1 = heapClassInst.heapFloat[r6];
    f2 = heapClassInst.heapFloat[r8];
    r3 = (r7 + r3) | 0;
    f1 = f1 + f2;
    r0 = (r0 + r1) | 0;
    r1 = (r5 + r4) | 0;
    r3 = r3 >> numDefine2;
    f1 = f1 * f0;
    r0 = r0 >> numDefine2;
    heapClassInst.heapFloat[r3] = f1;
    r1 = r1 >> numDefine2;
    f1 = heapClassInst.heapFloat[r0];
    f2 = heapClassInst.heapFloat[r1];
    r0 = (r7 + r4) | 0;
    f1 = f1 + f2;
    r0 = r0 >> numDefine2;
    f0 = f1 * f0;
    heapClassInst.heapFloat[r0] = f0;
    f1 = heapClassInst.heapFloat[fp + numDefineNeg4];
    f3 = heapClassInst.heapFloat[r9 + 1];
    f0 = heapClassInst.heapFloat[r9 + numDefine2];
    f2 = heapClassInst.heapFloat[r9 + numDefine3];
  } else {
    f0 = 1;
    f0 = f3 + f0;
    heapClassInst.heapFloat[g0] = f0;
    r0 = sp + numDefineNeg16;
    f0 = numDefineFloat05;
    sqrtf(i7);
    f2 = commonVariable.fg0 * f0;
    r0 = r0 >> numDefine2;
    heapClassInst.heapFloat[r0 + numDefine3] = f2;
    f3 = heapClassInst.heapFloat[r1 + numDefine9];
    f4 = heapClassInst.heapFloat[r1 + numDefine6];
    f3 = f3 - f4;
    f0 = f0 / commonVariable.fg0;
    f1 = f3 * f0;
    heapClassInst.heapFloat[fp + numDefineNeg4] = f1;
    f3 = heapClassInst.heapFloat[r1 + numDefine2];
    f4 = heapClassInst.heapFloat[r1 + numDefine8];
    f3 = f3 - f4;
    f3 = f3 * f0;
    heapClassInst.heapFloat[r0 + 1] = f3;
    f4 = heapClassInst.heapFloat[r1 + numDefine4];
    f5 = heapClassInst.heapFloat[r1 + 1];
    f4 = f4 - f5;
    f0 = f4 * f0;
    heapClassInst.heapFloat[r0 + numDefine2] = f0;
  }
  r0 = r2 >> numDefine2;
  heapClassInst.heapFloat[r0] = f1;
  heapClassInst.heapFloat[r0 + 1] = f3;
  heapClassInst.heapFloat[r0 + numDefine2] = f0;
  heapClassInst.heapFloat[r0 + numDefine3] = f2;
  return;
}

function znk13btConvexShape31localGetSupportVertexNonVirtualERK9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg48;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine2];
  r0 = r0 >> numDefine2;
  f0 = heapClassInst.heapFloat[r0];
  r1 = sp + numDefineNeg32;
  heapClassInst.heapFloat[fp + numDefineNeg8] = f0;
  f1 = heapClassInst.heapFloat[r0 + 1];
  r2 = r1 >> numDefine2;
  heapClassInst.heapFloat[r2 + 1] = f1;
  f2 = heapClassInst.heapFloat[r0 + numDefine2];
  r3 = heapClassInst.heap32[fp];
  r4 = heapClassInst.heap32[fp + 1];
  heapClassInst.heapFloat[r2 + numDefine2] = f2;
  f3 = f0 * f0;
  f4 = f1 * f1;
  f3 = f3 + f4;
  f4 = f2 * f2;
  heapClassInst.heap32[r2 + numDefine3] = heapClassInst.heap32[r0 + numDefine3];
  f3 = f3 + f4;
  f4 = numDefineFloat4044;
  if (f3 < f4) {
    heapClassInst.heap32[fp + numDefineNeg8] = numDefineNeg30432;
    heapClassInst.heap32[r2 + 1] = numDefineNeg30432;
    f2 = -1;
    heapClassInst.heap32[r2 + numDefine2] = numDefineNeg30432;
    heapClassInst.heap32[r2 + numDefine3] = 0;
    f1 = f2;
    f0 = f2;
  }
  f0 = f0 * f0;
  f1 = f1 * f1;
  f0 = f0 + f1;
  f1 = f2 * f2;
  f0 = f0 + f1;
  heapClassInst.heapFloat[g0] = f0;
  sqrtf(i7);
  f1 = 1;
  f0 = f1 / commonVariable.fg0;
  f1 = heapClassInst.heapFloat[fp + numDefineNeg8];
  f1 = f1 * f0;
  heapClassInst.heapFloat[fp + numDefineNeg8] = f1;
  f2 = heapClassInst.heapFloat[r2 + 1];
  f2 = f2 * f0;
  heapClassInst.heapFloat[r2 + 1] = f2;
  f3 = heapClassInst.heapFloat[r2 + numDefine2];
  f0 = f3 * f0;
  r0 = r4 >> numDefine2;
  heapClassInst.heapFloat[r2 + numDefine2] = f0;
  r5 = heapClassInst.heap32[r0 + 1];
  repeat4: do {
    if (r5 > numDefine7) {
      if (r5 === numDefine13) {
        f3 = heapClassInst.heapFloat[r0 + numDefine11];
        label = numDefine16;
        break repeat4;
      } else {
        if (r5 === numDefine10) {
          f3 = heapClassInst.heapFloat[r0 + numDefine11];
          label = numDefine16;
          break repeat4;
        } else {
          if (r5 !== numDefine8) {
            label = numDefine15;
            break repeat4;
          } else {
            f3 = heapClassInst.heapFloat[r0 + numDefine7];
            f4 = heapClassInst.heapFloat[r0 + numDefine3];
            f3 = f3 * f4;
            label = numDefine16;
            break repeat4;
          }
        }
      }
    } else {
      if (r5 === 0) {
        f3 = heapClassInst.heapFloat[r0 + numDefine11];
        label = numDefine16;
        break repeat4;
      } else {
        if (r5 === 1) {
          f3 = heapClassInst.heapFloat[r0 + numDefine11];
          label = numDefine16;
        } else {
          r5 = (r5 + numDefineNeg4) | 0;
          if (uint(r5) < uint(numDefine2)) {
            f3 = heapClassInst.heapFloat[r0 + numDefine11];
            label = numDefine16;
          } else {
            label = numDefine15;
          }
        }
      }
    }
  } while (false);
  if (label === numDefine15) {
    r0 = heapClassInst.heap32[r0];
    r0 = r0 >> numDefine2;
    r0 = heapClassInst.heap32[r0 + numDefine11];
    heapClassInst.heap32[g0] = r4;
    functionTable[r0 >> numDefine2](i7);
    f3 = commonVariable.fg0;
    f0 = heapClassInst.heapFloat[r2 + numDefine2];
    f2 = heapClassInst.heapFloat[r2 + 1];
    f1 = heapClassInst.heapFloat[fp + numDefineNeg8];
  }
  r0 = sp + numDefineNeg16;
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r4;
  heapClassInst.heap32[g0 + numDefine2] = r1;
  znk13btConvexShape44localGetSupportVertexWithoutMarginNonVirtualERK9btVector3(i7);
  r0 = r0 >> numDefine2;
  f1 = f1 * f3;
  f4 = heapClassInst.heapFloat[fp + numDefineNeg4];
  f5 = heapClassInst.heapFloat[r0 + numDefine2];
  f6 = heapClassInst.heapFloat[r0 + 1];
  f2 = f2 * f3;
  r0 = r3 >> numDefine2;
  f1 = f4 + f1;
  f0 = f0 * f3;
  f2 = f6 + f2;
  heapClassInst.heapFloat[r0] = f1;
  f0 = f5 + f0;
  heapClassInst.heapFloat[r0 + 1] = f2;
  heapClassInst.heapFloat[r0 + numDefine2] = f0;
  heapClassInst.heap32[r0 + numDefine3] = 0;
  return;
}

function znk13btConvexShape44localGetSupportVertexWithoutMarginNonVirtualERK9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let f12: number = 0.0;
  let f13: number = 0.0;
  let f14: number = 0.0;
  let f15: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg120;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1 + 1];
  r3 = heapClassInst.heap32[fp];
  r4 = heapClassInst.heap32[fp + numDefine2];
  repeat1: do {
    if (r2 > numDefine4) {
      if (r2 > numDefine9) {
        if (r2 === numDefine10) {
          r2 = heapClassInst.heap32[r1 + numDefine13];
          r5 = (r2 + numDefine2) | 0;
          r4 = r4 >> numDefine2;
          r5 = r5 % numDefine3 | 0;
          f0 = heapClassInst.heapFloat[r4];
          f1 = heapClassInst.heapFloat[r4 + 1];
          r2 = r2 << numDefine2;
          r0 = (r0 + numDefine28) | 0;
          r5 = r5 << numDefine2;
          f2 = heapClassInst.heapFloat[r4 + numDefine2];
          r4 = (r0 + r2) | 0;
          r0 = (r0 + r5) | 0;
          f3 = f0 * f0;
          f4 = f1 * f1;
          r4 = r4 >> numDefine2;
          r0 = r0 >> numDefine2;
          f3 = f3 + f4;
          f4 = f2 * f2;
          f3 = f3 + f4;
          f4 = heapClassInst.heapFloat[r4];
          f5 = heapClassInst.heapFloat[r0];
          f6 = numDefineFloat9165;
          if (f3 >= f6) {
            heapClassInst.heapFloat[g0] = f3;
            f3 = 1;
            sqrtf(i7);
            f3 = f3 / commonVariable.fg0;
            f0 = f0 * f3;
            f1 = f1 * f3;
            f2 = f2 * f3;
          } else {
            f0 = 1;
            f1 = 0;
            f2 = f1;
          }
          r0 = sp + numDefineNeg64;
          r4 = r0 >> numDefine2;
          heapClassInst.heap32[fp + numDefineNeg16] = 0;
          heapClassInst.heap32[r4 + 1] = 0;
          r0 = (r0 + r2) | 0;
          heapClassInst.heap32[r4 + numDefine2] = 0;
          r0 = r0 >> numDefine2;
          heapClassInst.heap32[r4 + numDefine3] = 0;
          heapClassInst.heapFloat[r0] = f4;
          f3 = heapClassInst.heapFloat[r1 + numDefine4];
          f6 = heapClassInst.heapFloat[r1 + numDefine3];
          f7 = heapClassInst.heapFloat[r1 + numDefine5];
          f3 = f1 * f3;
          f6 = f0 * f6;
          f8 = heapClassInst.heapFloat[r1 + numDefine11];
          f7 = f2 * f7;
          f3 = f3 * f5;
          f9 = heapClassInst.heapFloat[r4 + 1];
          f6 = f6 * f5;
          f10 = heapClassInst.heapFloat[fp + numDefineNeg16];
          f5 = f7 * f5;
          f7 = heapClassInst.heapFloat[r4 + numDefine2];
          f11 = f1 * f8;
          f9 = f9 + f3;
          f12 = f0 * f8;
          f10 = f10 + f6;
          f9 = f9 - f11;
          f10 = f10 - f12;
          f8 = f2 * f8;
          f7 = f7 + f5;
          f7 = f7 - f8;
          f13 = f0 * f10;
          f14 = f1 * f9;
          f13 = f13 + f14;
          f14 = f2 * f7;
          f13 = f13 + f14;
          f14 = numDefineNeg49440;
          if (f13 > f14) {
            f14 = f13;
          } else {
            f10 = 0;
            f9 = f10;
            f7 = f10;
          }
          r0 = sp + numDefineNeg80;
          r1 = r0 >> numDefine2;
          heapClassInst.heap32[fp + numDefineNeg20] = 0;
          heapClassInst.heap32[r1 + 1] = 0;
          r0 = (r0 + r2) | 0;
          heapClassInst.heap32[r1 + numDefine2] = 0;
          r0 = r0 >> numDefine2;
          f4 = -f4;
          heapClassInst.heap32[r1 + numDefine3] = 0;
          heapClassInst.heapFloat[r0] = f4;
          f4 = heapClassInst.heapFloat[r1 + 1];
          f13 = heapClassInst.heapFloat[fp + numDefineNeg20];
          f15 = heapClassInst.heapFloat[r1 + numDefine2];
          f3 = f4 + f3;
          f4 = f13 + f6;
          f4 = f4 - f12;
          f3 = f3 - f11;
          f5 = f15 + f5;
          f0 = f0 * f4;
          f1 = f1 * f3;
          f5 = f5 - f8;
          f0 = f0 + f1;
          f1 = f2 * f5;
          f0 = f0 + f1;
          r0 = r3 >> numDefine2;
          f1 = f0 > f14 ? f4 : f10;
          f2 = f0 > f14 ? f3 : f9;
          heapClassInst.heapFloat[r0] = f1;
          f0 = f0 > f14 ? f5 : f7;
          label = numDefine11;
          break repeat1;
        } else {
          if (r2 === numDefine13) {
            r0 = sp + numDefineNeg16;
            r2 = r0 >> numDefine2;
            heapClassInst.heap32[fp + numDefineNeg4] = heapClassInst.heap32[r1 + numDefine7];
            heapClassInst.heap32[r2 + 1] = heapClassInst.heap32[r1 + numDefine8];
            heapClassInst.heap32[r2 + numDefine2] = heapClassInst.heap32[r1 + numDefine2];
            r4 = r4 >> numDefine2;
            heapClassInst.heap32[r2 + numDefine3] = heapClassInst.heap32[r1 + numDefine10];
            r2 = sp + numDefineNeg32;
            heapClassInst.heap32[fp + numDefineNeg8] = heapClassInst.heap32[r4];
            f0 = heapClassInst.heapFloat[r4 + 1];
            r5 = r2 >> numDefine2;
            heapClassInst.heapFloat[r5 + 1] = f0;
            f1 = heapClassInst.heapFloat[r4 + numDefine2];
            heapClassInst.heapFloat[r5 + numDefine2] = f1;
            heapClassInst.heap32[r5 + numDefine3] = 0;
            r1 = heapClassInst.heap32[r1 + numDefine13];
            if (r1 === numDefine2) {
              r4 = 0;
              r5 = numDefine2;
              r6 = 1;
              f1 = f0;
            } else {
              if (r1 === 1) {
                r4 = 0;
                r5 = 1;
                r6 = numDefine2;
              } else {
                if (r1 !== 0) {
                  r0 = twoEStr10;
                  r1 = twoEStr7250;
                  heapClassInst.heap32[g0] = r0;
                  heapClassInst.heap32[g0 + 1] = r1;
                  heapClassInst.heap32[g0 + numDefine2] = numDefine175;
                  assertNew(i7);
                } else {
                  r4 = 1;
                  r5 = 0;
                  r6 = numDefine2;
                }
              }
            }
            r1 = r1 << numDefine2;
            r4 = r4 << numDefine2;
            r7 = (r0 + r4) | 0;
            r0 = (r0 + r1) | 0;
            r1 = (r2 + r4) | 0;
            r7 = r7 >> numDefine2;
            r0 = r0 >> numDefine2;
            r1 = r1 >> numDefine2;
            f0 = heapClassInst.heapFloat[r1];
            f2 = heapClassInst.heapFloat[r7];
            f3 = heapClassInst.heapFloat[r0];
            f4 = f0 * f0;
            f5 = f1 * f1;
            f4 = f4 + f5;
            heapClassInst.heapFloat[g0] = f4;
            sqrtf(i7);
            f4 = commonVariable.fg0;
            f5 = 0;
            if (f4 === f5) {
              r0 = sp + numDefineNeg48;
              r1 = (r0 + r4) | 0;
              r4 = r5 << numDefine2;
              r2 = (r2 + r4) | 0;
              r1 = r1 >> numDefine2;
              r2 = r2 >> numDefine2;
              heapClassInst.heapFloat[r1] = f2;
              f0 = heapClassInst.heapFloat[r2];
              if (f0 < f5) {
                f3 = -f3;
              }
              r1 = r6 << numDefine2;
              r4 = (r0 + r4) | 0;
              r1 = (r0 + r1) | 0;
              r4 = r4 >> numDefine2;
              r1 = r1 >> numDefine2;
              heapClassInst.heapFloat[r4] = f3;
              r3 = r3 >> numDefine2;
              heapClassInst.heap32[r1] = 0;
              r0 = r0 >> numDefine2;
              heapClassInst.heap32[r3] = heapClassInst.heap32[fp + numDefineNeg12];
              heapClassInst.heap32[r3 + 1] = heapClassInst.heap32[r0 + 1];
              heapClassInst.heap32[r3 + numDefine2] = heapClassInst.heap32[r0 + numDefine2];
              heapClassInst.heap32[r3 + numDefine3] = 0;
              return;
            } else {
              r0 = sp + numDefineNeg48;
              r4 = (r0 + r4) | 0;
              f2 = f2 / f4;
              r1 = r5 << numDefine2;
              r2 = (r2 + r1) | 0;
              r4 = r4 >> numDefine2;
              f0 = f0 * f2;
              r2 = r2 >> numDefine2;
              heapClassInst.heapFloat[r4] = f0;
              f0 = heapClassInst.heapFloat[r2];
              if (f0 < f5) {
                f3 = -f3;
              }
              r4 = r6 << numDefine2;
              r1 = (r0 + r1) | 0;
              r4 = (r0 + r4) | 0;
              r1 = r1 >> numDefine2;
              r4 = r4 >> numDefine2;
              f2 = f1 * f2;
              heapClassInst.heapFloat[r1] = f3;
              r1 = r3 >> numDefine2;
              heapClassInst.heapFloat[r4] = f2;
              r4 = r0 >> numDefine2;
              heapClassInst.heap32[r1] = heapClassInst.heap32[fp + numDefineNeg12];
              heapClassInst.heap32[r1 + 1] = heapClassInst.heap32[r4 + 1];
              heapClassInst.heap32[r1 + numDefine2] = heapClassInst.heap32[r4 + numDefine2];
              heapClassInst.heap32[r1 + numDefine3] = 0;
              return;
            }
          } else {
            label = numDefine40;
            break repeat1;
          }
        }
      } else {
        if (r2 === numDefine5) {
          r0 = r4 >> numDefine2;
          f0 = heapClassInst.heapFloat[r1 + numDefine5];
          r4 = heapClassInst.heap32[r1 + numDefine22];
          label = numDefine38;
          break repeat1;
        } else {
          if (r2 === numDefine8) {
            r0 = r3 >> numDefine2;
            heapClassInst.heap32[r0] = 0;
            heapClassInst.heap32[r0 + 1] = 0;
            heapClassInst.heap32[r0 + numDefine2] = 0;
            heapClassInst.heap32[r0 + numDefine3] = 0;
            return;
          } else {
            label = numDefine40;
            break repeat1;
          }
        }
      }
    } else {
      if (r2 === 0) {
        r0 = r4 >> numDefine2;
        f0 = heapClassInst.heapFloat[r1 + numDefine7];
        f1 = heapClassInst.heapFloat[r1 + numDefine9];
        f2 = heapClassInst.heapFloat[r1 + numDefine8];
        f3 = 0;
        f4 = -f0;
        f5 = heapClassInst.heapFloat[r0];
        f6 = heapClassInst.heapFloat[r0 + numDefine2];
        f7 = heapClassInst.heapFloat[r0 + 1];
        f8 = -f2;
        r0 = r3 >> numDefine2;
        f0 = f5 < f3 ? f4 : f0;
        f4 = -f1;
        f2 = f7 < f3 ? f8 : f2;
        heapClassInst.heapFloat[r0] = f0;
        f0 = f6 < f3 ? f4 : f1;
        label = numDefine11;
        break repeat1;
      } else {
        if (r2 === 1) {
          r4 = r4 >> numDefine2;
          f0 = heapClassInst.heapFloat[r1 + numDefine13];
          f1 = heapClassInst.heapFloat[r4];
          f2 = heapClassInst.heapFloat[r1 + numDefine17];
          f3 = heapClassInst.heapFloat[r1 + numDefine21];
          f4 = heapClassInst.heapFloat[r1 + numDefine14];
          f5 = heapClassInst.heapFloat[r4 + 1];
          f6 = heapClassInst.heapFloat[r1 + numDefine18];
          f7 = heapClassInst.heapFloat[r1 + numDefine22];
          f0 = f1 * f0;
          f4 = f5 * f4;
          f8 = heapClassInst.heapFloat[r1 + numDefine15];
          f9 = heapClassInst.heapFloat[r4 + numDefine2];
          f10 = heapClassInst.heapFloat[r1 + numDefine19];
          f11 = heapClassInst.heapFloat[r1 + numDefine23];
          f2 = f1 * f2;
          f6 = f5 * f6;
          f1 = f1 * f3;
          f3 = f5 * f7;
          f0 = f0 + f4;
          f4 = f9 * f8;
          f2 = f2 + f6;
          f5 = f9 * f10;
          f1 = f1 + f3;
          f3 = f9 * f11;
          f0 = f0 + f4;
          f2 = f2 + f5;
          f1 = f1 + f3;
          if (f0 >= f2) {
            r1 = numDefine2;
            r4 = 0;
            r1 = f0 < f1 ? r1 : r4;
          } else {
            r1 = numDefine2;
            r4 = 1;
            r1 = f2 < f1 ? r1 : r4;
          }
          r1 = r1 << numDefine4;
          r0 = (r0 + r1) | 0;
          r0 = r0 >> numDefine2;
          f0 = heapClassInst.heapFloat[r0 + numDefine15];
          f1 = heapClassInst.heapFloat[r0 + numDefine14];
          r1 = r3 >> numDefine2;
          heapClassInst.heap32[r1] = heapClassInst.heap32[r0 + numDefine13];
          heapClassInst.heapFloat[r1 + 1] = f1;
          heapClassInst.heapFloat[r1 + numDefine2] = f0;
          heapClassInst.heap32[r1 + numDefine3] = 0;
          return;
        } else {
          if (r2 === numDefine4) {
            r0 = r4 >> numDefine2;
            f0 = heapClassInst.heapFloat[r1 + numDefine5];
            r4 = heapClassInst.heap32[r1 + numDefine25];
            label = numDefine38;
          } else {
            label = numDefine40;
          }
        }
      }
    }
  } while (false);
  switch (label) {
    case numDefine11:
      heapClassInst.heapFloat[r0 + 1] = f2;
      heapClassInst.heapFloat[r0 + numDefine2] = f0;
      heapClassInst.heap32[r0 + numDefine3] = 0;
      return;
    case numDefine40:
      r1 = heapClassInst.heap32[r1];
      r1 = r1 >> numDefine2;
      r1 = heapClassInst.heap32[r1 + numDefine16];
      heapClassInst.heap32[g0] = r3;
      heapClassInst.heap32[g0 + 1] = r0;
      heapClassInst.heap32[g0 + numDefine2] = r4;
      functionTable[r1 >> numDefine2](i7);
      return;
    case numDefine38:
      r2 = heapClassInst.heap32[r1 + numDefine23];
      f1 = heapClassInst.heapFloat[r0];
      f2 = heapClassInst.heapFloat[r0 + 1];
      f3 = heapClassInst.heapFloat[r0 + numDefine2];
      f4 = heapClassInst.heapFloat[r1 + numDefine3];
      f5 = heapClassInst.heapFloat[r1 + numDefine4];
      heapClassInst.heap32[g0] = r3;
      heapClassInst.heapFloat[g0 + 1] = f1;
      heapClassInst.heapFloat[g0 + numDefine2] = f2;
      heapClassInst.heapFloat[g0 + numDefine3] = f3;
      heapClassInst.heap32[g0 + numDefine4] = r4;
      heapClassInst.heap32[g0 + numDefine5] = r2;
      heapClassInst.heapFloat[g0 + numDefine6] = f4;
      heapClassInst.heapFloat[g0 + numDefine7] = f5;
      heapClassInst.heapFloat[g0 + numDefine8] = f0;
      zl17convexHullSupportRK9btVector3PS0IS1(i7);
      return;
    default:
      break;
  }
}

function zl17convexHullSupportRK9btVector3PS0IS1(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine5];
  if (!(r0 < 1)) {
    f0 = heapClassInst.heapFloat[fp + numDefine8];
    f1 = heapClassInst.heapFloat[fp + numDefine3];
    f2 = heapClassInst.heapFloat[fp + numDefine7];
    f3 = heapClassInst.heapFloat[fp + numDefine2];
    f4 = heapClassInst.heapFloat[fp + numDefine6];
    f5 = heapClassInst.heapFloat[fp + 1];
    r1 = heapClassInst.heap32[fp];
    r2 = heapClassInst.heap32[fp + numDefine4];
    f1 = f1 * f0;
    f3 = f3 * f2;
    f5 = f5 * f4;
    r3 = 0;
    r4 = -1;
    f6 = numDefineNeg49440;
    repeat3: while (true) {
      r5 = r3 << numDefine4;
      r5 = (r2 + r5) | 0;
      r5 = r5 >> numDefine2;
      f7 = heapClassInst.heapFloat[r5];
      f8 = heapClassInst.heapFloat[r5 + 1];
      f7 = f5 * f7;
      f8 = f3 * f8;
      f9 = heapClassInst.heapFloat[r5 + numDefine2];
      f7 = f7 + f8;
      f8 = f1 * f9;
      f7 = f7 + f8;
      r5 = (r3 + 1) | 0;
      r4 = f7 > f6 ? r3 : r4;
      f6 = f7 > f6 ? f7 : f6;
      r3 = r5;
      if (!(r0 !== r5)) {
        break repeat3;
      }
    }
    if (r4 > -1) {
      r0 = r4 << numDefine4;
      r0 = (r2 + r0) | 0;
      r0 = r0 >> numDefine2;
      f1 = heapClassInst.heapFloat[r0];
      f3 = heapClassInst.heapFloat[r0 + numDefine2];
      f5 = heapClassInst.heapFloat[r0 + 1];
      r0 = r1 >> numDefine2;
      f1 = f1 * f4;
      f2 = f5 * f2;
      heapClassInst.heapFloat[r0] = f1;
      f0 = f3 * f0;
      heapClassInst.heapFloat[r0 + 1] = f2;
      heapClassInst.heapFloat[r0 + numDefine2] = f0;
      heapClassInst.heap32[r0 + numDefine3] = 0;
      return;
    }
  }
  r1 = twoEStr6249;
  r2 = twoEStr7250;
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = r2;
  heapClassInst.heap32[g0 + numDefine2] = numDefine108;
  assertNew(i7);
}

function zn15CProfileManager13StartProfileEPKc(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = zn15CProfileManager11CurrentNodeE;
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0];
  r2 = heapClassInst.heap32[fp];
  r3 = r1 >> numDefine2;
  r4 = heapClassInst.heap32[r3];
  if (r4 !== r2) {
    r4 = (r1 + numDefine24) | 0;
    repeat3: while (true) {
      r4 = r4 >> numDefine2;
      r4 = heapClassInst.heap32[r4];
      if (r4 !== 0) {
        r5 = r4 >> numDefine2;
        r5 = heapClassInst.heap32[r5];
        if (r5 !== r2) {
          r4 = (r4 + numDefine28) | 0;
        } else {
          label = numDefine3;
          break repeat3;
        }
      } else {
        label = numDefine6;
        break repeat3;
      }
    }
    switch (label) {
      case numDefine6:
        heapClassInst.heap32[g0] = numDefine32;
        znwj(i7);
        r4 = commonVariable.rg0;
        r5 = r4 >> numDefine2;
        heapClassInst.heap32[r5] = r2;
        heapClassInst.heap32[r5 + 1] = 0;
        heapClassInst.heap32[r5 + numDefine2] = 0;
        heapClassInst.heap32[r5 + numDefine3] = 0;
        heapClassInst.heap32[r5 + numDefine4] = 0;
        heapClassInst.heap32[r5 + numDefine5] = r1;
        heapClassInst.heap32[r5 + numDefine6] = 0;
        heapClassInst.heap32[r5 + numDefine7] = 0;
        heapClassInst.heap32[g0] = r4;
        zn12CProfileNode5ResetEv(i7);
        r1 = heapClassInst.heap32[r3 + numDefine6];
        heapClassInst.heap32[r5 + numDefine7] = r1;
        heapClassInst.heap32[r3 + numDefine6] = r4;
        r1 = r4;
        break;
      case numDefine3:
        r1 = r4;
        break;
      default:
        break;
    }
    heapClassInst.heap32[r0] = r1;
  }
  r0 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r0 + 1];
  r1 = (r1 + 1) | 0;
  heapClassInst.heap32[r0 + 1] = r1;
  r1 = heapClassInst.heap32[r0 + numDefine4];
  r2 = (r1 + 1) | 0;
  heapClassInst.heap32[r0 + numDefine4] = r2;
  if (!(r1 !== 0)) {
    r1 = sp + numDefineNeg8;
    heapClassInst.heap32[g0] = r1;
    heapClassInst.heap32[g0 + 1] = 0;
    r2 = zl13gProfileClock2E0;
    getTimeOfDay(i7);
    r2 = r2 >> numDefine2;
    r2 = heapClassInst.heap32[r2];
    r2 = r2 >> numDefine2;
    r1 = r1 >> numDefine2;
    r3 = heapClassInst.heap32[fp + numDefineNeg2];
    r4 = heapClassInst.heap32[r2];
    r3 = (r3 - r4) | 0;
    r1 = heapClassInst.heap32[r1 + 1];
    r2 = heapClassInst.heap32[r2 + 1];
    r1 = (r1 - r2) | 0;
    r2 = (r3 * numDefineN6) | 0;
    r1 = (r1 + r2) | 0;
    heapClassInst.heap32[r0 + numDefine3] = r1;
  }
  return;
}

function zn12CProfileNode5ResetEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  repeat1: while (true) {
    r0 = r0 >> numDefine2;
    heapClassInst.heap32[r0 + 1] = 0;
    heapClassInst.heap32[r0 + numDefine2] = 0;
    r1 = heapClassInst.heap32[r0 + numDefine6];
    if (!(r1 === 0)) {
      heapClassInst.heap32[g0] = r1;
      zn12CProfileNode5ResetEv(i7);
    }
    r0 = heapClassInst.heap32[r0 + numDefine7];
    if (r0 !== 0) {
      continue repeat1;
    } else {
      break repeat1;
    }
  }
  return;
}

function powf(sp: number): void {
  let value = heapClassInst.heapFloat[sp >> numDefine2];
  let value2 = heapClassInst.heapFloat[(sp + numDefine4) >> numDefine2];
  commonVariable.fg0 = Math.pow(value, value2);
}

function abort(sp: number): void {
  assert(false);
}

function znaj(sp: number): void {
  mallocNew(sp);
}

function zdaPv(sp: number): void {
  free(sp);
}

function emitOpenHarmony32(data: number): void {
  heapClassInst.heapU32[commonVariable.gAddrEmit >> numDefine2] = data;
  commonVariable.gAddrEmit += numDefine4;
}

function emitOpenHarmonyStart(addr: number): void {
  commonVariable.gAddrEmit = addr;
}

function emitOpenHarmony8(data: number): void {
  heapClassInst.heapU8[commonVariable.gAddrEmit] = data;
  commonVariable.gAddrEmit += 1;
}

function emitOpenHarmony16(data: number): void {
  heapClassInst.heapU16[commonVariable.gAddrEmit >> 1] = data;
  commonVariable.gAddrEmit += numDefine2;
}

function emitOpenHarmonyFill(data: number, size: number): void {
  for (let j = 0; j < size; j++) {
    heapClassInst.heapU8[commonVariable.gAddrEmit] = data;
    commonVariable.gAddrEmit += 1;
  }
}

function emitOpenHarmonyString(v: string): void {
  for (let char of v) {
    let data: number = char.charCodeAt(0);

    heapClassInst.heapU8[commonVariable.gAddrEmit] = data;
    commonVariable.gAddrEmit += 1;
  }
}

function initHeap(): void {
  heapClassInst.heap = new ArrayBuffer(mandreelTotalMemory);
  heapClassInst.heap8 = new Int8Array(heapClassInst.heap);
  heapClassInst.heapU8 = new Uint8Array(heapClassInst.heap);
  heapClassInst.heap16 = new Int16Array(heapClassInst.heap);
  heapClassInst.heapU16 = new Uint16Array(heapClassInst.heap);
  heapClassInst.heap32 = new Int32Array(heapClassInst.heap);
  heapClassInst.heapU32 = new Uint32Array(heapClassInst.heap);
  heapClassInst.heapFloat = new Float32Array(heapClassInst.heap);
  heapClassInst.heapDouble = new Float64Array(heapClassInst.heap);

  for (let i = 0; i < mandreelTotalMemory / numDefine4; i++) {
    heapClassInst.heapU32[i] = 0;
  }
}

function assertUnalign(): void {
  dump('fatal error: unaligned memory access detected!!!!');
  assert(false);
}

function cxaPureVirtual(sp: number): void {
  assert(false);
}

function mandreelCallConstructors(pt: number, size: number, stackPos: number): void {
  let ptr = pt;
  ptr = ptr >> numDefine2;
  for (let i = 0; i < size; ++i) {
    let tag = heapClassInst.heap32[ptr];
    let ptrId = heapClassInst.heap32[ptr + 1];
    functionTable[ptrId >> numDefine2](stackPos);
    ptr += numDefine2;
  }
}

function cmpfacets(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r0 = r0 >> numDefine2;
  r1 = r1 >> numDefine2;
  r0 = heapClassInst.heap32[r0];
  r1 = heapClassInst.heap32[r1];
  r0 = r0 >> numDefine2;
  r1 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[r0 + numDefine5];
  r3 = heapClassInst.heap32[r1 + numDefine5];
  if (r2 !== r3) {
    r0 = (r3 - r2) | 0;
    commonVariable.rg0 = r0;
    return;
  } else {
    r2 = heapClassInst.heap32[r1 + 1];
    r3 = heapClassInst.heap32[r0 + 1];
    r0 = twoEStr538;
    r3 = r3 === 0 ? r0 : r3;
    r2 = r2 === 0 ? r0 : r2;
    heapClassInst.heap32[g0] = r3;
    heapClassInst.heap32[g0 + 1] = r2;
    strcmp(i7);
    return;
  }
}

function strcmp(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = r1 ^ r0;
  r2 = r2 & numDefine3;
  repeat1: do {
    if (r2 === 0) {
      r2 = r0 & numDefine3;
      repeat3: do {
        if (r2 !== 0) {
          r2 = r0 | numDefineNeg4;
          repeat5: while (true) {
            if (r2 !== 0) {
              r3 = heapClassInst.heapU8[r0];
              r4 = heapClassInst.heapU8[r1];
              if (r3 === 0) {
                break repeat5;
              } else {
                r5 = r4 & numDefine255;
                if (r3 === r5) {
                  r0 = (r0 + 1) | 0;
                  r1 = (r1 + 1) | 0;
                  r2 = (r2 + 1) | 0;
                } else {
                  break repeat5;
                }
              }
            } else {
              break repeat3;
            }
          }
          r0 = r3 << numDefine24;
          r1 = r4 << numDefine24;
          break repeat1;
        }
      } while (false);
      repeat11: while (true) {
        r2 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r2];
        r3 = r1 >> numDefine2;
        r4 = r2 & numDefineNeg62144;
        r3 = heapClassInst.heap32[r3];
        r4 = r4 ^ numDefineNeg62144;
        r5 = (r2 + numDefineNeg43009) | 0;
        r4 = r4 & r5;
        if (r4 !== 0) {
          break repeat11;
        } else {
          r4 = r3 & numDefineNeg62144;
          r4 = r4 ^ numDefineNeg62144;
          r5 = (r3 + numDefineNeg43009) | 0;
          r4 = r4 & r5;
          if (r4 !== 0) {
            break repeat11;
          } else {
            r0 = (r0 + numDefine4) | 0;
            r1 = (r1 + numDefine4) | 0;
            if (!(r2 === r3)) {
              break repeat11;
            }
          }
        }
      }
      r0 = r2 & numDefine255;
      repeat16: do {
        if (!(r0 === 0)) {
          r0 = r2 & numDefine255;
          r1 = r3 & numDefine255;
          if (!(r0 !== r1)) {
            label = numDefine19;
            while (true) {
              r2 = r2 >>> numDefine8;
              r3 = r3 >>> numDefine8;
              r0 = r2 & numDefine255;
              if (r0 === 0) {
                break repeat16;
              } else {
                r1 = r3 & numDefine255;
                if (!(r0 === r1)) {
                  break repeat16;
                }
              }
            }
          }
        }
      } while (false);
      r2 = r2 & numDefine255;
      r3 = r3 & numDefine255;
      r2 = (r2 - r3) | 0;
      commonVariable.rg0 = r2;
      return;
    } else {
      repeat22: while (true) {
        r2 = heapClassInst.heapU8[r0];
        r3 = heapClassInst.heapU8[r1];
        if (r2 === 0) {
          break repeat22;
        } else {
          r4 = r3 & numDefine255;
          if (r2 === r4) {
            r0 = (r0 + 1) | 0;
            r1 = (r1 + 1) | 0;
          } else {
            break repeat22;
          }
        }
      }
      r0 = r2 << numDefine24;
      r1 = r3 << numDefine24;
    }
  } while (false);
  r0 = r0 >> numDefine24;
  r1 = r1 >> numDefine24;
  r0 = (r0 - r1) | 0;
  commonVariable.rg0 = r0;
  return;
}

function cmplocales(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r0 = r0 >> numDefine2;
  r1 = r1 >> numDefine2;
  r0 = heapClassInst.heap32[r0];
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine38];
  r0 = heapClassInst.heap32[r0 + numDefine38];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r1;
  strcmp(i7);
  return;
}

function zn21btCollisionDispatcher19defaultNearCallbackER16btBroadphasePairRSRK16btDispatcherInfo(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg184;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heap32[fp];
  r1 = r1 >> numDefine2;
  r2 = r0 >> numDefine2;
  r3 = heapClassInst.heap32[r2];
  r4 = heapClassInst.heap32[r1];
  r5 = heapClassInst.heap32[r1 + 1];
  r3 = r3 >> numDefine2;
  r4 = r4 >> numDefine2;
  r5 = r5 >> numDefine2;
  r4 = heapClassInst.heap32[r4];
  r5 = heapClassInst.heap32[r5];
  r3 = heapClassInst.heap32[r3 + numDefine6];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r4;
  heapClassInst.heap32[g0 + numDefine2] = r5;
  functionTable[r3 >> numDefine2](i7);
  r3 = commonVariable.rg0;
  repeat1: do {
    if (!(r3 === 0)) {
      r3 = heapClassInst.heap32[fp + numDefine2];
      r6 = heapClassInst.heap32[r1 + numDefine2];
      if (r6 === 0) {
        r6 = heapClassInst.heap32[r2];
        r6 = r6 >> numDefine2;
        r6 = heapClassInst.heap32[r6 + numDefine2];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r4;
        heapClassInst.heap32[g0 + numDefine2] = r5;
        heapClassInst.heap32[g0 + numDefine3] = 0;
        functionTable[r6 >> numDefine2](i7);
        r6 = commonVariable.rg0;
        heapClassInst.heap32[r1 + numDefine2] = r6;
        if (r6 === 0) {
          break repeat1;
        }
      }
      r0 = ztv16btManifoldResult;
      r1 = sp + numDefineNeg160;
      r0 = (r0 + numDefine8) | 0;
      r2 = r1 >> numDefine2;
      heapClassInst.heap32[fp + numDefineNeg40] = r0;
      heapClassInst.heap32[r2 + 1] = 0;
      heapClassInst.heap32[r2 + numDefine34] = r4;
      r0 = r4 >> numDefine2;
      heapClassInst.heap32[r2 + numDefine35] = r5;
      heapClassInst.heap32[r2 + numDefine2] = heapClassInst.heap32[r0 + 1];
      heapClassInst.heap32[r2 + numDefine3] = heapClassInst.heap32[r0 + numDefine3];
      heapClassInst.heap32[r2 + numDefine4] = heapClassInst.heap32[r0 + numDefine4];
      heapClassInst.heap32[r2 + numDefine5] = heapClassInst.heap32[r0 + numDefine5];
      heapClassInst.heap32[r2 + numDefine6] = heapClassInst.heap32[r0 + numDefine6];
      heapClassInst.heap32[r2 + numDefine7] = heapClassInst.heap32[r0 + numDefine7];
      heapClassInst.heap32[r2 + numDefine8] = heapClassInst.heap32[r0 + numDefine8];
      heapClassInst.heap32[r2 + numDefine9] = heapClassInst.heap32[r0 + numDefine9];
      heapClassInst.heap32[r2 + numDefine10] = heapClassInst.heap32[r0 + numDefine9];
      heapClassInst.heap32[r2 + numDefine11] = heapClassInst.heap32[r0 + numDefine10];
      heapClassInst.heap32[r2 + numDefine12] = heapClassInst.heap32[r0 + numDefine11];
      heapClassInst.heap32[r2 + numDefine13] = heapClassInst.heap32[r0 + numDefine12];
      heapClassInst.heap32[r2 + numDefine14] = heapClassInst.heap32[r0 + numDefine13];
      heapClassInst.heap32[r2 + numDefine15] = heapClassInst.heap32[r0 + numDefine14];
      heapClassInst.heap32[r2 + numDefine16] = heapClassInst.heap32[r0 + numDefine15];
      r7 = r5 >> numDefine2;
      heapClassInst.heap32[r2 + numDefine17] = heapClassInst.heap32[r0 + numDefine16];
      heapClassInst.heap32[r2 + numDefine18] = heapClassInst.heap32[r7 + 1];
      heapClassInst.heap32[r2 + numDefine19] = heapClassInst.heap32[r7 + numDefine2];
      heapClassInst.heap32[r2 + numDefine20] = heapClassInst.heap32[r7 + numDefine3];
      heapClassInst.heap32[r2 + numDefine21] = heapClassInst.heap32[r7 + numDefine4];
      heapClassInst.heap32[r2 + numDefine22] = heapClassInst.heap32[r7 + numDefine5];
      heapClassInst.heap32[r2 + numDefine23] = heapClassInst.heap32[r7 + numDefine6];
      heapClassInst.heap32[r2 + numDefine24] = heapClassInst.heap32[r7 + numDefine7];
      heapClassInst.heap32[r2 + numDefine25] = heapClassInst.heap32[r7 + numDefine8];
      heapClassInst.heap32[r2 + numDefine26] = heapClassInst.heap32[r7 + numDefine9];
      heapClassInst.heap32[r2 + numDefine27] = heapClassInst.heap32[r7 + numDefine10];
      heapClassInst.heap32[r2 + numDefine28] = heapClassInst.heap32[r7 + numDefine11];
      heapClassInst.heap32[r2 + numDefine29] = heapClassInst.heap32[r7 + numDefine12];
      heapClassInst.heap32[r2 + numDefine30] = heapClassInst.heap32[r7 + numDefine13];
      heapClassInst.heap32[r2 + numDefine31] = heapClassInst.heap32[r7 + numDefine14];
      heapClassInst.heap32[r2 + numDefine32] = heapClassInst.heap32[r7 + numDefine15];
      r0 = r6 >> numDefine2;
      heapClassInst.heap32[r2 + numDefine33] = heapClassInst.heap32[r7 + numDefine16];
      r0 = heapClassInst.heap32[r0];
      r2 = r3 >> numDefine2;
      r7 = heapClassInst.heap32[r2 + numDefine2];
      if (r7 !== 1) {
        r0 = r0 >> numDefine2;
        r0 = heapClassInst.heap32[r0 + numDefine3];
        heapClassInst.heap32[g0] = r6;
        heapClassInst.heap32[g0 + 1] = r4;
        heapClassInst.heap32[g0 + numDefine2] = r5;
        heapClassInst.heap32[g0 + numDefine3] = r3;
        heapClassInst.heap32[g0 + numDefine4] = r1;
        functionTable[r0 >> numDefine2](i7);
        f0 = commonVariable.fg0;
        f1 = heapClassInst.heapFloat[r2 + numDefine3];
        if (!(f1 <= f0)) {
          heapClassInst.heapFloat[r2 + numDefine3] = f0;
        }
      } else {
        r0 = r0 >> numDefine2;
        r0 = heapClassInst.heap32[r0 + numDefine2];
        heapClassInst.heap32[g0] = r6;
        heapClassInst.heap32[g0 + 1] = r4;
        heapClassInst.heap32[g0 + numDefine2] = r5;
        heapClassInst.heap32[g0 + numDefine3] = r3;
        heapClassInst.heap32[g0 + numDefine4] = r1;
        functionTable[r0 >> numDefine2](i7);
        return;
      }
    }
  } while (false);
  return;
}

function imandreelRestoreGlcontext(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function iMandreelTextureAsyncGetPackOffset(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg1032;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = heapClassInst.heap32[fp + numDefine2];
  r3 = heapClassInst.heap32[fp + numDefine3];
  r4 = sp + numDefineNeg1024;
  r5 = 0;
  repeat1: while (true) {
    r6 = heapClassInst.heapU8[r0];
    if (r6 === 0) {
      break repeat1;
    } else {
      r7 = r6 << numDefine24;
      r7 = r7 >> numDefine24;
      r7 = (r7 + numDefineNeg65) | 0;
      r8 = numDefine26;
      r9 = (r6 + numDefine32) | 0;
      r6 = uint(r7) < uint(r8) ? r9 : r6;
      r7 = r6 & numDefine255;
      r8 = numDefine47;
      r6 = r7 === numDefine92 ? r8 : r6;
      r0 = (r0 + 1) | 0;
      r7 = r6 & numDefine255;
      if (!(r7 !== numDefine47)) {
        r7 = r5 & numDefine255;
        r5 = r6;
        if (r7 === numDefine47) {
          continue repeat1;
        }
      }
      r5 = (r4 + 1) | 0;
      heapClassInst.heap8[r4] = r6;
      r4 = r5;
      r5 = r6;
      continue repeat1;
    }
  }
  r0 = zl24gPFirstTextureAsyncInfo;
  r5 = 0;
  heapClassInst.heap8[r4] = r5;
  repeat8: while (true) {
    r0 = r0 >> numDefine2;
    r0 = heapClassInst.heap32[r0];
    if (r0 !== 0) {
      r4 = sp + numDefineNeg1024;
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r4;
      strcmp(i7);
      r4 = commonVariable.rg0;
      if (!(r4 !== 0)) {
        r4 = r0 >> numDefine2;
        r5 = heapClassInst.heap32[r4 + numDefine64];
        if (!(r5 === -1)) {
          label = numDefine8;
          break repeat8;
        }
      }
      r0 = (r0 + numDefine280) | 0;
      continue repeat8;
    } else {
      label = numDefine11;
      break repeat8;
    }
  }
  switch (label) {
    case numDefine11:
      r0 = 0;
      commonVariable.rg0 = r0;
      return;
    case numDefine8:
      r0 = r1 >> numDefine2;
      r1 = heapClassInst.heap32[r4 + numDefine68];
      heapClassInst.heap32[r0] = r1;
      r0 = r2 >> numDefine2;
      r1 = heapClassInst.heap32[r4 + numDefine69];
      heapClassInst.heap32[r0] = r1;
      r0 = heapClassInst.heap32[r4 + numDefine64];
      r1 = zl17gApPackFileNames;
      r0 = r0 << numDefine2;
      r0 = (r1 + r0) | 0;
      r0 = r0 >> numDefine2;
      r0 = heapClassInst.heap32[r0];
      heapClassInst.heap32[g0] = r3;
      heapClassInst.heap32[g0 + 1] = r0;
      strcpy(i7);
      r0 = 1;
      commonVariable.rg0 = r0;
      return;
    default:
      break;
  }
}

function iMandreelTextureAsyncIsCompressed(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg1032;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = heapClassInst.heap32[fp + numDefine2];
  r3 = sp + numDefineNeg1024;
  r4 = 0;
  repeat1: while (true) {
    r5 = heapClassInst.heapU8[r0];
    if (r5 === 0) {
      break repeat1;
    } else {
      r6 = r5 << numDefine24;
      r6 = r6 >> numDefine24;
      r6 = (r6 + numDefineNeg65) | 0;
      r7 = numDefine26;
      r8 = (r5 + numDefine32) | 0;
      r5 = uint(r6) < uint(r7) ? r8 : r5;
      r6 = r5 & numDefine255;
      r7 = numDefine47;
      r5 = r6 === numDefine92 ? r7 : r5;
      r0 = (r0 + 1) | 0;
      r6 = r5 & numDefine255;
      if (!(r6 !== numDefine47)) {
        r6 = r4 & numDefine255;
        r4 = r5;
        if (r6 === numDefine47) {
          continue repeat1;
        }
      }
      r4 = (r3 + 1) | 0;
      heapClassInst.heap8[r3] = r5;
      r3 = r4;
      r4 = r5;
      continue repeat1;
    }
  }
  r0 = zl24gPFirstTextureAsyncInfo;
  r4 = 0;
  heapClassInst.heap8[r3] = r4;
  repeat8: while (true) {
    r0 = r0 >> numDefine2;
    r0 = heapClassInst.heap32[r0];
    if (r0 !== 0) {
      r3 = sp + numDefineNeg1024;
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r3;
      strcmp(i7);
      r3 = commonVariable.rg0;
      if (r3 !== 0) {
        r0 = (r0 + numDefine280) | 0;
        continue repeat8;
      } else {
        label = numDefine7;
        break repeat8;
      }
    } else {
      label = numDefine10;
      break repeat8;
    }
  }
  switch (label) {
    case numDefine10:
      r0 = -1;
      commonVariable.rg0 = r0;
      return;
    case numDefine7:
      r0 = r0 >> numDefine2;
      r1 = r1 >> numDefine2;
      r3 = heapClassInst.heap32[r0 + numDefine65];
      heapClassInst.heap32[r1] = r3;
      r1 = r2 >> numDefine2;
      r2 = heapClassInst.heap32[r0 + numDefine66];
      heapClassInst.heap32[r1] = r2;
      r0 = heapClassInst.heap32[r0 + numDefine67];
      commonVariable.rg0 = r0;
      return;
    default:
      break;
  }
}

function imandreelViewportResize(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function mandreelFlashTcpOnError(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function z31MandreelDefaultDebugMsgCallbackiPKc(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  heapClassInst.heap32[g0] = r0;
  sandboxOutputDebugString(i7);
  return;
}

function fwrite(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine2];
  r1 = heapClassInst.heap32[fp];
  r2 = heapClassInst.heap32[fp + 1];
  if (!(uint(r0) > uint(numDefine9))) {
    r0 = zl13sFileStdout;
  }
  r3 = r0 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  r3 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[r3 + numDefine2];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r1;
  heapClassInst.heap32[g0 + numDefine2] = 1;
  heapClassInst.heap32[g0 + numDefine3] = r2;
  functionTable[r3 >> numDefine2](i7);
  return;
}

function mandreelInternalSetResolution(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = zl25sMandreelInternalWidth;
  r1 = zl26sMandreelInternalHeight;
  r0 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[fp];
  r1 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[fp + 1];
  heapClassInst.heap32[r0] = r2;
  heapClassInst.heap32[r1] = r3;
  return;
}

function resize(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function myMandreelCallConstructors(ptr: number, size: number, stackPos: number): void {
  myHeapNewPos = commonVariable.heapNewPos;
  heapClassInst.myHeap = new ArrayBuffer(mandreelTotalMemory);
  heapClassInst.myHeap8 = new Int8Array(heapClassInst.myHeap);
  heapClassInst.myHeap32 = new Int32Array(heapClassInst.myHeap);
  for (let i = 0; i < mandreelTotalMemory / numDefine4; i++) {
    heapClassInst.myHeap32[i] = heapClassInst.heap32[i];
  }
  mandreelCallConstructors(ptr, size, stackPos);
}

export {
  deBugLog,
  strcmp,
  mandreelFlashTcpOnError,
  resize,
  mandreelInternalSetResolution,
  tlsfRealloc,
  myMandreelCallConstructors,
  myHeapNewPos,
  fwrite,
  zn21btCollisionDispatcher19defaultNearCallbackER16btBroadphasePairRSRK16btDispatcherInfo,
  z31MandreelDefaultDebugMsgCallbackiPKc,
  cmpfacets,
  cmplocales,
  iMandreelTextureAsyncGetPackOffset,
  iMandreelTextureAsyncIsCompressed,
  imandreelViewportResize,
  imandreelRestoreGlcontext
};

export { powf, abort, znaj, zdaPv, initHeap, cxaPureVirtual, mandreelCallConstructors };

export { zgvzn11btMatrix3x311getIdentityEvE14identityMatrix, zgvzn11btTransform11getIdentityEvE17identityTransform };

export { landscape02Vtx, ztin16btCollisionWorld17RayResultCallbackE, ztsn16btCollisionWorld17RayResultCallbackE };

export { ztvn16btCollisionWorld24ClosestRayResultCallbackE, ztin16btCollisionWorld24ClosestRayResultCallbackE };

export { ztsn16btCollisionWorld24ClosestRayResultCallbackE, zti13btMotionState, zts13btMotionState };

export { ztv20btDefaultMotionState, zti20btDefaultMotionState, zts20btDefaultMotionState, zti17btTypedConstraint };

export { zts17btTypedConstraint, zti13btTypedObject, zts13btTypedObject, ztv7RagDoll, zti7RagDoll, zts7RagDoll };

export { ztv13BenchmarkDemo, zti13BenchmarkDemo, zts13BenchmarkDemo, zti15DemoApplication, zts15DemoApplication };

export { zl10raycastBar, twoEStr3, twoEStr4, twoEStr5, twoEStr6, twoEStr7, zl7TaruVtx, landscapeVtx, landscape01Vtx };

export { landscape03Vtx, landscape04Vtx, landscape05Vtx, landscape06Vtx, landscape07Vtx, landscape08Vtx, landscapeVtxCount };

export { landscapeIdx, landscape01Idx, landscape02Idx, landscape03Idx, landscape04Idx, landscape05Idx, landscape06Idx };

export { landscape07Idx, landscape08Idx, landscapeIdxCount, zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E02E02E0 };

export { zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E12E02E1 };

export { zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E22E02E2 };

export { zzn11btTransform11getIdentityEvE17identityTransform, ztv14BenchmarkDemo4, zti14BenchmarkDemo4 };

export { zts14BenchmarkDemo4, zl14benchmarkDemo4, zti21btBroadphaseInterface, zts21btBroadphaseInterface };

export { zti25btOverlappingPairCallback, zts25btOverlappingPairCallback, zti22btOverlappingPairCache };

export { zts22btOverlappingPairCache, ztv15btNullPairCache, zti15btNullPairCache, zts15btNullPairCache };

export { twoEStr11, twoEStr112, twoEStr213, twoEStr314, ztv20btAxisSweep3InternalItE, zti20btAxisSweep3InternalItE };

export { zts20btAxisSweep3InternalItE, ztv12btAxisSweep3, zti12btAxisSweep3, zts12btAxisSweep3 };

export { ztv20btCollisionAlgorithm, zti20btCollisionAlgorithm, zts20btCollisionAlgorithm, ztin6btDbvt8ICollideE };

export { ztsn6btDbvt8ICollideE, twoEStr1118, twoEStr22, ztv18btDbvtTreeCollider, zti18btDbvtTreeCollider };

export { zts18btDbvtTreeCollider, ztv19BroadphaseRayTester, zti19BroadphaseRayTester, zts19BroadphaseRayTester };

export { ztv20BroadphaseAabbTester, zti20BroadphaseAabbTester, zts20BroadphaseAabbTester, twoEStr18 };

export { ztv16btDbvtBroadphase, zti16btDbvtBroadphase, zts16btDbvtBroadphase, ztv12btDispatcher, zti12btDispatcher };

export { zts12btDispatcher, zti21btNodeOverlapCallback, zts21btNodeOverlapCallback, twoEStr10, twoEStr212, twoEStr313 };

export { twoEStr414, twoEStr515, twoEStr616, twoEStr717, twoEStr820, twoEStr9, gOverlappingPairs, zti17btOverlapCallback };

export { zts17btOverlapCallback };

export { ztvzn28btHashedOverlappingPairCache19cleanProxyFromPairsEP17btBroadphaseProxyP12btDispatcherE17CleanPairCallback };

export { ztizn28btHashedOverlappingPairCache19cleanProxyFromPairsEP17btBroadphaseProxyP12btDispatcherE17CleanPairCallback };

export { ztszn28btHashedOverlappingPairCache19cleanProxyFromPairsEP17btBroadphaseProxyP12btDispatcherE17CleanPairCallback };

export { ztvzn28btHashedOverlappingPairCache37removeOverlappingPairsContainingProxyEP17btBroadphaseProxyP12btDispatcherE18RemovePairCallback };

export { ztizn28btHashedOverlappingPairCache37removeOverlappingPairsContainingProxyEP17btBroadphaseProxyP12btDispatcherE18RemovePairCallback };

export { ztszn28btHashedOverlappingPairCache37removeOverlappingPairsContainingProxyEP17btBroadphaseProxyP12btDispatcherE18RemovePairCallback };

export { gRemovePairs, ztv28btHashedOverlappingPairCache, zti28btHashedOverlappingPairCache };

export { zts28btHashedOverlappingPairCache, twoEStr121, gAddedPairs, twoEStr222, twoEStr323, twoEStr424, twoEStr525 };

export { twoEStr626, twoEStr727, gFindPairs, twoEStr32, twoEStr133, twoEStr234, twoEStr335, ztv14btQuantizedBvh };

export { zti14btQuantizedBvh, zts14btQuantizedBvh, twoEStr537, twoEStr638, twoEStr739, twoEStr941, twoEStr1143 };

export { maxIterations, twoEStr1844, twoEStr1921, twoEStr21, twoEStr2246, ztv30btActivatingCollisionAlgorithm };

export { zti30btActivatingCollisionAlgorithm, zts30btActivatingCollisionAlgorithm, twoEStr59, twoEStr160 };

export { ztv26btBoxBoxCollisionAlgorithm, zti26btBoxBoxCollisionAlgorithm, zts26btBoxBoxCollisionAlgorithm };

export { zti36btDiscreteCollisionDetectorInterface, zts36btDiscreteCollisionDetectorInterface, ztv16btBoxBoxDetector };

export { zti16btBoxBoxDetector, zts16btBoxBoxDetector, twoEStr65, twoEStr166, gNumManifold };

export { ztin36btDiscreteCollisionDetectorInterface6ResultE, ztsn36btDiscreteCollisionDetectorInterface6ResultE };

export { ztv23btCollisionPairCallback, zti23btCollisionPairCallback, zts23btCollisionPairCallback, twoEStr169 };

export { twoEStr270, twoEStr371, twoEStr472, twoEStr573, ztv21btCollisionDispatcher, zti21btCollisionDispatcher };

export { zts21btCollisionDispatcher, twoEStr674, twoEStr775, twoEStr876, twoEStr977, ztv17btCollisionObject };

export { zti17btCollisionObject, zts17btCollisionObject, twoEStr78, ztin16btCollisionWorld20ConvexResultCallbackE };

export { ztsn16btCollisionWorld20ConvexResultCallbackE, zti30btConvexPenetrationDepthSolver };

export { zts30btConvexPenetrationDepthSolver, ztvn12btConvexCast10CastResultE, ztin12btConvexCast10CastResultE };

export { ztsn12btConvexCast10CastResultE };

export { ztvzn16btCollisionWorld13rayTestSingleERK11btTransformS2P17btCollisionObjectPK16btCollisionShapeS2RNS17RayResultCallbackEE15LocalInfoAdder2 };

export { ztizn16btCollisionWorld13rayTestSingleERK11btTransformS2P17btCollisionObjectPK16btCollisionShapeS2RNS17RayResultCallbackEE15LocalInfoAdder2 };

export { ztszn16btCollisionWorld13rayTestSingleERK11btTransformS2P17btCollisionObjectPK16btCollisionShapeS2RNS17RayResultCallbackEE15LocalInfoAdder2 };

export { ztvzn16CollsionQuerySingObjectPK };

export { ztizn16btCollisionWorldCollisionShape };

export { ztszn16btConvexResultLocalInfoAdder };

export { zti24btBroadphaseAabbCallback, zts24btBroadphaseAabbCallback, zti23btBroadphaseRayCallback };

export { zts23btBroadphaseRayCallback, ztv17DebugDrawcallback, zti17DebugDrawcallback, zts17DebugDrawcallback };

export { zti18btTriangleCallback, zts18btTriangleCallback, zti31btInternalTriangleIndexCallback };

export { zts31btInternalTriangleIndexCallback, ztv16btCollisionWorld, zti16btCollisionWorld };

export { zts16btCollisionWorld, zti16btManifoldResult, zts16btManifoldResult, ztv21btSingleSweepCallback };

export { zti21btSingleSweepCallback, zts21btSingleSweepCallback, ztv19btSingleRayCallback, zti19btSingleRayCallback };

export { zts19btSingleRayCallback, twoEStr382, twoEStr483, twoEStr584, twoEStr685, twoEStr786, twoEStr887, twoEStr988 };

export { ztvzn16CollsionQuerySingConvex };

export { ztizn16btCollisionTransformConvexcastCallback0 };

export { ztszn16btCollisionQuerySingleShapeRK11 };

export { zti28btTriangleConvexcastCallback, zts28btTriangleConvexcastCallback };

export { ztvzn16CollsionQuery };

export { ztizn16btCollisionWorld17objectQuerySing };

export { ztszn16btCollisionWorld17object };

export { ztvzn16CollsionTestCallback0 };

export { ztizn16btCollisionWorld13rayObjectPK16bt };

export { ztszn16btCollisionObjectPK };

export { zti25btTriangleRaycastCallback, zts25btTriangleRaycastCallback };

export { ztvzn16CollsionTestERK };

export { ztizn16btCollisionWorld13rayTestSingle };

export { ztszn16btCollisionWorld };

export { twoEStr1089, twoEStr1190, twoEStr1291, twoEStr1392, twoEStr1493 };

export { zzn16btCollisionWorld16updateSingleAabbEP17btCollisionObjectE8reportMe2EB, twoEStr1594 };

export { twoEStr1695, twoEStr1796, twoEStr1897, twoEStr1998, ztv22btCompoundLeafCallback, zti22btCompoundLeafCallback };

export { zts22btCompoundLeafCallback, twoEStr99, twoEStr1100, twoEStr2101, twoEStr3102, twoEStr4103, twoEStr5104 };

export { twoEStr6105, twoEStr7106, ztv28btCompoundCollisionAlgorithm, zti28btCompoundCollisionAlgorithm };

export { zts28btCompoundCollisionAlgorithm, twoEStr109, ztv24btConvexTriangleCallback, zti24btConvexTriangleCallback };

export { zts24btConvexTriangleCallback };

export { zn33btCollisionObjectS1RK };

export { ztizn33btConvexConcave };

export { ztszn33btConvex };

export { ztv15btTriangleShape, zti15btTriangleShape, zts15btTriangleShape, zti23btPolyhedralConvexShape };

export { zts23btPolyhedralConvexShape, zti21btConvexInternalShape, zts21btConvexInternalShape, zti13btConvexShape };

export { zts13btConvexShape, zti16btCollisionShape, zts16btCollisionShape, twoEStr1110, twoEStr3112 };

export { ztv33btConvexConcaveCollisionAlgorithm, zti33btConvexConcaveCollisionAlgorithm };

export { zts33btConvexConcaveCollisionAlgorithm, zti30btCollisionAlgorithmCreateFunc };

export { zts30btCollisionAlgorithmCreateFunc, ztvn23btConvexConvexAlgorithm10CreateFuncE };

export { ztin23btConvexConvexAlgorithm10CreateFuncE, ztsn23btConvexConvexAlgorithm10CreateFuncE };

export { ztv24btPerturbedContactResult, zti24btPerturbedContactResult, zts24btPerturbedContactResult, twoEStr115 };

export { twoEStr4119, twoEStr5120, ztv23btConvexConvexAlgorithm, zti23btConvexConvexAlgorithm };

export { zts23btConvexConvexAlgorithm, ztv31btConvexPlaneCollisionAlgorithm, zti31btConvexPlaneCollisionAlgorithm };

export { zts31btConvexPlaneCollisionAlgorithm, ztvn31btConvexPlaneCollisionAlgorithm10CreateFuncE };

export { ztin31btConvexPlaneCollisionAlgorithm10CreateFuncE, ztsn31btConvexPlaneCollisionAlgorithm10CreateFuncE };

export { zti24btCollisionConfiguration, zts24btCollisionConfiguration };

export { ztvn33btConvexConcaveCollisionAlgorithm10CreateFuncE, ztin33btConvexConcaveCollisionAlgorithm10CreateFuncE };

export { ztsn33btConvexConcaveCollisionAlgorithm10CreateFuncE, ztvn33btConvexConcaveCollisionAlgorithm17SwappedCreateFuncE };

export { ztin33btConvexConcaveCollisionAlgorithm17SwappedCreateFuncE };

export { ztsn33btConvexConcaveCollisionAlgorithm17SwappedCreateFuncE, ztvn28btCompoundCollisionAlgorithm10CreateFuncE };

export { ztin28btCompoundCollisionAlgorithm10CreateFuncE, ztsn28btCompoundCollisionAlgorithm10CreateFuncE };

export { ztvn28btCompoundCollisionAlgorithm17SwappedCreateFuncE, ztin28btCompoundCollisionAlgorithm17SwappedCreateFuncE };

export { ztsn28btCompoundCollisionAlgorithm17SwappedCreateFuncE, ztvn16btEmptyAlgorithm10CreateFuncE };

export { ztin16btEmptyAlgorithm10CreateFuncE, ztsn16btEmptyAlgorithm10CreateFuncE };

export { ztvn32btSphereSphereCollisionAlgorithm10CreateFuncE, ztin32btSphereSphereCollisionAlgorithm10CreateFuncE };

export { ztsn32btSphereSphereCollisionAlgorithm10CreateFuncE, ztvn34btSphereTriangleCollisionAlgorithm10CreateFuncE };

export { ztin34btSphereTriangleCollisionAlgorithm10CreateFuncE, ztsn34btSphereTriangleCollisionAlgorithm10CreateFuncE };

export { ztvn26btBoxBoxCollisionAlgorithm10CreateFuncE, ztin26btBoxBoxCollisionAlgorithm10CreateFuncE };

export { ztsn26btBoxBoxCollisionAlgorithm10CreateFuncE, twoEStr128, twoEStr1129, ztv31btDefaultCollisionConfiguration };

export { zti31btDefaultCollisionConfiguration, zts31btDefaultCollisionConfiguration, ztv16btEmptyAlgorithm };

export { zti16btEmptyAlgorithm, zts16btEmptyAlgorithm, ztv16btManifoldResult, twoEStr2149, twoEStr3150, twoEStr5152 };

export { twoEStr155, twoEStr1156, twoEStr2157, twoEStr3158, ztv25btSimulationIslandManager, zti25btSimulationIslandManager };

export { zts25btSimulationIslandManager, ztv32btSphereSphereCollisionAlgorithm, zti32btSphereSphereCollisionAlgorithm };

export { zts32btSphereSphereCollisionAlgorithm, ztv34btSphereTriangleCollisionAlgorithm };

export { zti34btSphereTriangleCollisionAlgorithm, zts34btSphereTriangleCollisionAlgorithm, ztv22SphereTriangleDetector };

export { zti22SphereTriangleDetector, zts22SphereTriangleDetector, twoEStr173, twoEStr2175, ztv10btBoxShape };

export { zti10btBoxShape, zts10btBoxShape, twoEStr181 };

export { ztvzn22btBvhTriangleMeshShape14performRaycastEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback };

export { ztizn22btBvhTriangleMeshShape14performRaycastEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback };

export { ztszn22btBvhTriangleMeshShape14performRaycastEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback };

export { ztvzn22btBvhTriangleMeshShape17performConvexcastEP18btTriangleCallbackRK9btVector3S4S4S4E21MyNodeOverlapCallback };

export { ztizn22btBvhTriangleMeshShape17performConvexcastEP18btTriangleCallbackRK9btVector3S4S4S4E21MyNodeOverlapCallback };

export { ztszn22btBvhTriangleMeshShape17performConvexcastEP18btTriangleCallbackRK9btVector3S4S4S4E21MyNodeOverlapCallback };

export { ztvznk22btBvhTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback };

export { ztiznk22btBvhTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback };

export { ztsznk22btBvhTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback };

export { twoEStr5186, twoEStr6187, twoEStr7188, twoEStr8189, ztv22btBvhTriangleMeshShape, zti22btBvhTriangleMeshShape };

export { zts22btBvhTriangleMeshShape, zti19btTriangleMeshShape, zts19btTriangleMeshShape, zti14btConcaveShape };

export { zts14btConcaveShape, twoEStr194, twoEStr4198, twoEStr6199, ztv14btCapsuleShape, zti14btCapsuleShape };

export { zts14btCapsuleShape, twoEStr200, ztv14btConcaveShape, twoEStr219, twoEStr3222, ztv17btConvexHullShape };

export { zti17btConvexHullShape, zts17btConvexHullShape, zti34btPolyhedralConvexAabbCachingShape };

export { zts34btPolyhedralConvexAabbCachingShape, twoEStr5223, twoEStr6224, twoEStr6232, ztv13btConvexShape };

export { twoEStr6249, twoEStr7250 };

export { ztvzn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4E20NodeTriangleCallback };

export { ztizn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4E20NodeTriangleCallback };

export { ztszn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4E20NodeTriangleCallback };

export { ztvzn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4E29QuantizedNodeTriangleCallback };

export { ztizn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4E29QuantizedNodeTriangleCallback };

export { ztszn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4E29QuantizedNodeTriangleCallback };

export { twoEStr10306, twoEStr18314, twoEStr19315, twoEStr20316, ztv14btOptimizedBvh, zti14btOptimizedBvh };

export { zts14btOptimizedBvh, twoEStr7331, zgvzn34btPolyhedralConvexAabbCachingShape15recalcLocalAabbEvE11Directions };

export { zzn34btPolyhedralConvexAabbCachingShape15recalcLocalAabbEvE11Directions, twoEStr342, ztv13btSphereShape };

export { zti13btSphereShape, zts13btSphereShape, twoEStr349, twoEStr1350, twoEStr3352, twoEStr5354, twoEStr6355, twoEStr7356 };

export { twoEStr8357, twoEStr9358, ztv23btStridingMeshInterface, zti23btStridingMeshInterface };

export { zts23btStridingMeshInterface, ztv31btInternalTriangleIndexCallback, ztv18btTriangleCallback, twoEStr367 };

export { twoEStr1368, ztv26btTriangleIndexVertexArray, zti26btTriangleIndexVertexArray, zts26btTriangleIndexVertexArray };

export { twoEStr372, ztv21SupportVertexCallback, zti21SupportVertexCallback, zts21SupportVertexCallback };

export { ztvznk19btTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4E16FilteredCallback };

export { ztiznk19btTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4E16FilteredCallback };

export { ztsznk19btTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4E16FilteredCallback };

export { twoEStr3375, ztv19btTriangleMeshShape, ztv16btPointCollector, zti16btPointCollector, zts16btPointCollector };

export { ztv27btContinuousConvexCollision, zti27btContinuousConvexCollision, zts27btContinuousConvexCollision };

export { zti12btConvexCast, zts12btConvexCast, ztv12btConvexCast, ztv15btGjkConvexCast, zti15btGjkConvexCast };

export { zts15btGjkConvexCast, zzn12gjkepa2Impl3GJK13projectoriginERK9btVector3S3S3PfRjE4imd3 };

export { zzn12gjkepa2Impl3EPA6expandEjPNS3GJK3sSVEPNS05sFaceEjRNS08sHorizonEE4i2m3 };

export { ztv30btGjkEpaPenetrationDepthSolver, zti30btGjkEpaPenetrationDepthSolver };

export { zts30btGjkEpaPenetrationDepthSolver, gNumDeepPenetrationChecks, ztv17btGjkPairDetector };

export { zti17btGjkPairDetector, zts17btGjkPairDetector, gNumGjkChecks, twoEStr425, twoEStr1426, twoEStr2427 };

export { twoEStr3428, gContactBreakingThreshold, twoEStr434, twoEStr3437, twoEStr4438, ztv28btTriangleConvexcastCallback };

export { ztv22btSubsimplexConvexCast, zti22btSubsimplexConvexCast, zts22btSubsimplexConvexCast, twoEStr457 };

export { twoEStr1458, ztvn16btCollisionWorld27ClosestConvexResultCallbackE };

export { ztin16btCollisionWorld27ClosestConvexResultCallbackE, ztsn16btCollisionWorld27ClosestConvexResultCallbackE };

export { twoEStr36, twoEStr239, ztv21btConeTwistConstraint, zti21btConeTwistConstraint, zts21btConeTwistConstraint };

export { twoEStr1340, twoEStr24, twoEStr442, twoEStr543, twoEStr846, twoEStr947, twoEStr1149, twoEStr29 };

export { ztv17btHingeConstraint, zti17btHingeConstraint, zts17btHingeConstraint, twoEStr130, twoEStr231, twoEStr332 };

export { twoEStr433, gNumSplitImpulseRecoveries, zti18btConstraintSolver, zts18btConstraintSolver };

export { ztv35btSequentialImpulseConstraintSolver, zti35btSequentialImpulseConstraintSolver };

export { zts35btSequentialImpulseConstraintSolver, zgvzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed };

export { zzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed, twoEStr248, twoEStr34955, twoEStr450 };

export { twoEStr551, twoEStr652, twoEStr753, twoEStr854, twoEStr955, twoEStr1056, twoEStr1157, twoEStr76 };

export { zti23btDiscreteDynamicsWorld, zts23btDiscreteDynamicsWorld, zti15btDynamicsWorld, zts15btDynamicsWorld };

export { ztin25btSimulationIslandManager14IslandCallbackE, ztsn25btSimulationIslandManager14IslandCallbackE };

export { ztv34btClosestNotMeConvexResultCallback, zti34btClosestNotMeConvexResultCallback };

export { zts34btClosestNotMeConvexResultCallback };

export { ztvzn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoE27InplaceSolverIslandCallback };

export { ztizn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoE27InplaceSolverIslandCallback };

export { ztszn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoE27InplaceSolverIslandCallback };

export { twoEStr87, twoEStr188, twoEStr289, twoEStr794, twoEStr895, gNumClampedCcdMotions, twoEStr996, twoEStr1097 };

export { twoEStr1198, twoEStr1299, twoEStr13100, twoEStr1461, twoEStr1562, twoEStr16101, ztv15btDynamicsWorld };

export { ztv23btDiscreteDynamicsWorld, zl8uniqueId, ztv11btRigidBody, zti11btRigidBody, zts11btRigidBody };

export { twoEStr4144, gDisableDeactivation, gNumAlignedAllocs, gNumAlignedFree, zn15CProfileManager12FrameCounterE };

export { zn15CProfileManager4RootE, zl13gProfileClock2E0, zn15CProfileManager11CurrentNodeE, twoEStr729 };

export { zn4RwL12RwCatlistE2E0, zn4RwL12RwCatlistE2E1, zn4RwL12RwCatlistE2E2 };

export { llvm2EEh2ECatch2EAll2EValue, ztin4Rw10RwFacetE, ztsn4Rw10RwFacetE };

export { ztin4Rw17RwSynchronizedE, ztsn4Rw17RwSynchronizedE, twoEStr4131, twoEStr15132, twoEStr26 };

export { zn4RwL13RwWhatBufE, zn4RwL16RwWhatRefcntE, twoEStr3133, twoEStr47, twoEStr5134 };

export { zzn4RwL13RwVfmtwhatEPcjiS0E7Fname, zzn4RwL13RwVfmtwhatEPcjiS0E6buffer, twoEStr7136 };

export { zzn4RwL13RwVfmtwhatEPcjiS0E8Catset, zzn4RwL13RwVfmtwhatEPcjiS0E4msgs };

export { zzn4RwL13RwVfmtwhatEPcjiS0E5Cat, zzn4Rw10RwThrowEizE6errors, twoEStr8137, twoEStr9138, twoEStr10139 };

export { twoEStr11140, twoEStr12141, twoEStr138142, twoEStr14143, twoEStr159144, twoEStr16145, twoEStr17146, twoEStr18147 };

export { twoEStr19148, twoEStr20149, twoEStr21150, twoEStr22151, twoEStr23152, twoEStr24153, twoEStr25154, twoEStr2610 };

export { twoEStr27, twoEStr28155, twoEStr29156, twoEStr30, twoEStr31, twoEStr32157, twoEStr33, twoEStr134, twoEStr235 };

export { twoEStr336, twoEStr437, ztvn4Rw10RwFacetE, twoEStr538 };

export { zzn4Rw10RwFacet9CManageEPS0NS013CFacetTypeEPKcPFS1JS4EE12nStdFacets };

export { zzn4Rw10RwFacet9CManageEPS0NS013CFacetTypeEPKcPFS1JS4EE10stdFacets };

export { zzn4Rw10RwFacet9CManageEPS0NS013CFacetTypeEPKcPFS1JS4EE13stdFacetBuf };

export { zzn4Rw10RwFacet9CManageEPS0NS013CFacetTypeEPKcPFS1JS4EE17stdFacetBufsize };

export { zzn4Rw10RwFacetD4EvE9destroyed, zn4Rw9RwCatsE, twoEStr785, zzn4Rw11RwLocale9CManageEPS0PKcE6global };

export { zzn4Rw11RwLocale9CManageEPS0PKcE5ginit, zzn4Rw11RwLocale9CManageEPS0PKcE9nLocales };

export { zzn4Rw11RwLocale9CManageEPS0PKcE7locales, zzn4Rw11RwLocale9CManageEPS0PKcE10localeBuf };

export { zzn4Rw11RwLocale9CManageEPS0PKcE14localeBufsize, zzn4Rw11RwLocale9CManageEPS0PKcE7classic };

export { zzn4Rw11RwLocale9CManageEPS0PKcE12classicBody, zn4RwL22RwClassicOnceInitE2E02EB };

export { zn4RwL12RwClassicE, twoEStr292167, twoEStr10100175, twoEStr12102177 };

export { zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE4init2EB };

export { zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE8catalogs };

export { zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE11catalogBuf };

export { zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE15catalogBufsize };

export { zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE10nCatalogs };

export { zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE11largestCat };

export { twoEStr115180, twoEStr1116181, twoEStr2131, twoEStr4133 };

export { zzn4Rw16RwLocaleNameEiPKcRNS14RwPodArrayIcLj256EEEE11localeRoot };

export { znss11CNullRefE, ztvst8messagesIcE, ztist8messagesIcE, ztsst8messagesIcE, ztist13messagesBase };

export { ztsst13messagesBase, twoEStr2360, twoEStr3361, twoEStr4362, ztvst9typeInfo, ztist9typeInfo, ztsst9typeInfo };

export { sMaxMemory, sCurrentMemory, blockNull, twoEStr643, twoEStr1648, twoEStr4651, twoEStr5652, myCtype };

export { zl8nextRand, twoEStr7654, twoEStr9655, zl8padLine, zl10strtokPos, zti14CFileInterface, zts14CFileInterface };

export { ztv11CFileSystem, zti11CFileSystem, zts11CFileSystem, zl13sFileStdout, ztv7CFileLS, zti7CFileLS };

export { zts7CFileLS, ztv10CFileCloud, zti10CFileCloud, zts10CFileCloud, zl10sASockets, ztv11CFileStdout };

export { zti11CFileStdout, zts11CFileStdout, twoEStr31677, twoEStr32678, twoEStr33679, twoEStr34680, twoEStr35681 };

export { twoEStr37683, twoEStr38684, zn12mandreelB64L9b64CharsE, zn12mandreelB64L11b64IndexesE };

export { zl25sMandreelInternalWidth, zl26sMandreelInternalHeight, gMsgcallback, zl24gPFirstTextureAsyncInfo };

export { zl17gApPackFileNames, zgvz21MandreelGetTickCountE7sFirst, zz21MandreelGetTickCountE7sFirst };

export { zz29MandreelInternalPreupdateE8sBfirst2EB, twoEStr779, twoEStr3782, twoEStr4783, twoEStr5784, twoEStr6785 };

export { zz24MandreelInternalInitE54s723478567MandreelMandreelInternalSetResolution };

export { zz24MandreelInternalInitE56s723478567MandreelIMandreelTextureAsyncIsCompressed };

export { zz24MandreelInternalInitE57s723478567MandreelIMandreelTextureAsyncGetPackOffset };

export { zz24MandreelInternalInitE29s723478567MandreelResize };

export { zz24MandreelInternalInitE48s723478567MandreelImandreelRestoreGlcontext };

export { zz24MandreelInternalInitE46s723478567MandreelImandreelViewportResize };

export { ztvn10Cxxabiv120SiClassTypeInfoE, ztin10Cxxabiv120SiClassTypeInfoE };

export { ztsn10Cxxabiv120SiClassTypeInfoE, ztin10Cxxabiv117ClassTypeInfoE };

export { ztsn10Cxxabiv117ClassTypeInfoE, ztvn10Cxxabiv117ClassTypeInfoE };

export { ztvn10Cxxabiv121VmiClassTypeInfoE, ztin10Cxxabiv121VmiClassTypeInfoE };

export { ztsn10Cxxabiv121VmiClassTypeInfoE, zl11gAChannels, zl7gBInit2EB, twoEStr221, twoEStr1222 };

export { zl21gPFirstSoundDuration, twoEStr3224, twoEStr4225, zl15gIFreeChannels, zl15gAFreeChannels, zl6gBLog };

export { twoEStr12233, twoEStr22243, twoEStr24245, twoEStr26247, twoEStr27248, twoEStr28249, twoEStr29250, twoEStr30251 };

export { twoEStr31252, twoEStr32253, twoEStr33254, twoEStr34255, twoEStr35256 };

export { zzl32MandreelInitTcpSocketLibrayvE47s723478567MandreelMandreelFlashTcpOnError, zl13sFifoErrors };

export { zn5myGlL9mContextE, llvm2EGlobalCtors, llvm2EGlobalDtors, llvm2EUsed, memcpy };

export {
  /**
   * 变量声明
   */
  heapClassInst,
  mandreelTotalMemory,
  mandreelStackMemory,
  gStackPointer,

  /**
   * 函数声明
   */
  cosf,
  dump,
  fillPtrFromString,
  fmodf,
  free,
  llvmWriteDouble,
  mallocNew,
  mallocInt,
  assert,
  alert,
  printf,
  vsnprintf,
  sandboxOutputDebugString,
  puts,
  getStringFromPtr,
  vPrintf,
  functionTable,
  blockMergeNext,
  strtol,
  myArgTest,
  llvmReadDouble,
  dtostr,
  strcpy,
  blockLocateFree,
  registerDelegate,
  swrite,
  uint,
  GetItemArr,
  MandreelDocument,
  MandreelCanvas,
  MandreelCanvasDiv,
  sinf,
  assertNew,
  znwj,
  zdlPv,
  sqrtf,
  getTimeOfDay,
  dateNow,
  pause,
  updateMandreelStats,
  acosf,
  realloc,
  atan2f,
  llvmMoveDouble,
  zn15CProfileManager13StartProfileEPKc,
  zn12CProfileNode5ResetEv
};

export {
  zn20btAlignedObjectArrayI16btBroadphasePairE17quickSortInternalI29btBroadphasePairSortPredicateEEvTIi,
  zn20btAxisSweep3InternalItE11sortMaxDownEitP12btDispatcherb,
  zn20btAxisSweep3InternalItE11sortMinDownEitP12btDispatcherb,
  znk20btAxisSweep3InternalItE8quantizeEPtRK9btVector3i,
  zn20btAlignedObjectArrayI18btQuantizedBvhNodeE7reserveEi,
  znk14btQuantizedBvh8quantizeEPtRK9btVector3i,
  zn6btDbvt9collideTVEPK10btDbvtNodeRK12btDbvtAabbMmRNS8ICollideE,
  znk14btQuantizedBvh9serializeEPvjb,
  z15btTransformAabbRK9btVector3S1FRK11btTransformRSS5,
  zn14btQuantizedBvh9buildTreeEii,
  zn14btQuantizedBvhD2Ev,
  zn28btCompoundCollisionAlgorithm26preallocateChildAlgorithmsEP17btCollisionObjectS1,
  znk14btQuantizedBvh26reportAabbOverlappingNodexEP21btNodeOverlapCallbackRK9btVector3S4,
  zn15btTransformUtil22calculateDiffAxisAngleERK11btTransformS2R9btVector3Rf,
  znk11btMatrix3x311getRotationER12btQuaternion,
  znk13btConvexShape31localGetSupportVertexNonVirtualERK9btVector3,
  jsMandreelFlashTcpUpdate,
  mandreelAddValidFopenfile,
  waMandreelAudioUpdate,
  mandreelAudioIsLogEnabled,
  mandreelAudioGetAudioDriverName,
  mandreelFread,
  mandreelFclose,
  mandreelFeof,
  mandreelFtell,
  mandreelFseek,
  mandreelUngetc,
  mandreelWritels,
  mandreelWritecloud,
  mandreelOpenls,
  mandreelReadcloud,
  mandreelFopen,
  mandreelReadls,
  mandreelOpencloud,
  mandreelInternalCreateWindow,
  iMandreelRegisterExternalCallback,
  z30MandreelFopenEnableCheckfatb,
  mandreelTextureAsyncSetData,
  znk13btConvexShape44localGetSupportVertexWithoutMarginNonVirtualERK9btVector3
};

export {
  emitOpenHarmony32,
  emitOpenHarmonyStart,
  emitOpenHarmony8,
  emitOpenHarmony16,
  emitOpenHarmonyFill,
  emitOpenHarmonyString,
  swriteIndex,
  mandreelCacheFiles,
  sufix,
  tlsfPtr,
  imandreelGl,
  assertUnalign,
  fileIds,
  arrayIdsOgl,
  mandreelGetlocalstorage,
  CMalloc
};
